Le mie sfide tendono ad essere un po 'difficili e poco attraenti. Quindi qui qualcosa di facile e divertente.

La sequenza di Alcuin

La sequenza di Alcuin A(n) è definita contando i triangoli. A(n)è il numero di triangoli con lati interi e perimetro n. Questa sequenza è chiamata dopo Alcuin di York.

I primi elementi di questa sequenza, a partire da n = 0sono:

0, 0, 0, 1, 0, 1, 1, 2, 1, 3, 2, 4, 3, 5, 4, 7, 5, 8, 7, 10, 8, ...

Ad esempio A(9) = 3, perché gli unici triangoli con lati e perimetro interi 9sono 1 - 4 - 4, 3 - 3 - 3e 2 - 3 - 4. Puoi vedere i 3 triangoli validi in basso.

Ci sono alcuni schemi abbastanza interessanti in questa sequenza. Per esempio A(2*k) = A(2*k - 3).

Per ulteriori informazioni, vedere A005044 su OEIS.

Sfida

Ma la tua sfida riguarda la rappresentazione binaria di questi numeri. Se convertiamo ciascun numero di sequenza nella sua rappresentazione binaria, li inseriamo in vettori di colonna e li allineamo, crea un'immagine binaria piuttosto interessante.

Nell'immagine seguente puoi vedere la rappresentazione binaria dei numeri di sequenza A(0), A(1), ..., A(149). Nella prima colonna puoi vedere la rappresentazione binaria di A(1), nella seconda colonna la rappresentazione di A(1)e così via.

Puoi vedere una sorta di motivo ripetuto in questa immagine. Sembra anche un po 'come un frattale, se ad esempio guardi l'immagine con i numeri di sequenza A(600), A(601), ..., A(899).

Il tuo compito è generare un'immagine del genere. La tua funzione, il tuo script riceveranno due numeri interi 0 <= m < ne dovrà generare l'immagine binaria della sequenza di Alcuin A(m), A(m+1), A(m+2), ..., A(n-2), A(n-1). Quindi l'ingresso 0, 150genera la prima immagine, l'ingresso 600, 900la seconda immagine.

Puoi utilizzare qualsiasi formato grafico popolare che desideri. Diciamo che ogni formato che può essere convertito in png usando image.online-convert.com . In alternativa, è possibile visualizzare l'immagine sullo schermo. Non sono consentite righe bianche iniziali!

Questo è code-golf. Quindi vince il codice più breve (in byte).

J ( 52 45 (Codepage 437))

Questo sarebbe permesso (penso)

[:|:' █'{~[:#:[:([:<.48%~*:+24+6*]*2|])(}.i.)

Discarica esadecimale

(Niente di speciale, il quadrato nero è DB ₁₆ o 219 ₁₀ nella tabella codici 437.)

0000: 5b 3a 7c 3a 27 20 db 27 7b 7e 5b 3a 23 3a 5b 3a   [:|:' .'{~[:#:[:
0010: 28 5b 3a 3c 2e 34 38 25 7e 2a 3a 2b 32 34 2b 36   ([:<.48%~*:+24+6
0020: 2a 5d 2a 32 7c 5d 29 28 7d 2e 69 2e 29            *]*2|])(}.i.)

uso

Questo produce come segue (I tag del codice lo rovinano aggiungendo spazio tra le righe):

   A=:[:|:' █'{~[:#:[:([:<.48%~*:+24+6*]*2|])(}.i.)
   0 A 100
                                                                             █ █████████████████████                                          
                                                     █ ██████████████████████ █              █ █████                          
                                     █ ██████████████ █          █ ██████████ █      █ ██████ █                   
                         █ ██████████ █      █ ██████ █    █ ████ █    █ ████ █  █ ██ █  █ ██ █  █ █  
                 █ ██████ █    █ ████ █  █ ██ █  █ ██ █  █  █  █  █  █  ██ ██ ██  ██  ██  ██  ██  ██
           █ ████ █  █ ██ █  █  █  █  ██  ██  ██  ██  ██  █  █  █  █ ██ █  █ ████ █                               
       █ ██ █  █  ██  ██  ██  █  █ ██ █                █ ██ █  █  ██  ██  ██  █  █ ██ █                                   
   █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █    
   2000 A 2100
████████████████████████████████████████████████████████████████████████████████████████████████████

████████████████████████████████████████████████████████████████████████████████████████████████████
                                                                             █ █████████████████████
                             █ ██████████████████████████████████████████████ █
     █ ██████████████████████ █                      █ ██████████████████████ █
█████ █          █ ██████████ █          █ ██████████ █          █ ██████████ █          █ █████████
 ████ █    █ ████ █    █ ████ █    █ ████ █    █ ████ █    █ ████ █    █ ████ █    █ ████ █    █ ███
█  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █
██  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █ ██ ██ █
 █ ██ ██ ██ ██ ██ █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  ██ ██ ██ ██ ██  █  █
  ██ ██ ██  █  █  ██ ██ ██  █  █  █  █  █  █  █  █  █  █  █  █  █  █ ██ ██ ██ █  █  █  █ ██ █  █ ██
 █ ██ █  █ ██ █  █ ██ █  █ ██ █  █  █  █  █  █  █  █  █  █  ██ ██ ██  █  █  ██  ██ ██ ██  ██  ██  ██
  ██  ██  ██  ██  ██  ██  ██  ██ ██ ██  █  █  █  █  █  █ ██ █  █ ██ █  █ ████ █    █ ██████ █
█ █                        █ ████ █  █ ██ █  █  █  █  ██  ██  ██  ██  ██  █  █  █  █ ██ █  █ ████ █
 █ ██ █                █ ██ █  █  ██  ██  ██  █  █ ██ █                █ ██ █  █  ██  ██  ██  █  █ █
██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██

Nella console J standard, non c'è spazio tra le linee, quindi chiamo la regola "In alternativa, è possibile visualizzare l'immagine sullo schermo". (Da nessuna parte ha detto che questa immagine doveva essere rappresentata come un formato di immagine sensibile internamente)

EDIT: Jconsole (al contrario di JQT) usa la codepage 437 come impostazione predefinita e rende i rettangoli correttamente quando li usano da una stringa.

Mathematica, 126 122 121 89 byte

Image[1-Thread@IntegerDigits[l=Round[(#+3#~Mod~2)^2/48]&/@Range@##,2,⌈2~Log~Max@l⌉]]&

Questo definisce una funzione senza nome che prende i due numeri interi come parametri e visualizza l'immagine sullo schermo. Traccia ogni quadrato come un singolo pixel, ma se ti piace puoi effettivamente ingrandire.

Ora sto usando una formula esplicita fornita nell'articolo OEIS (il primo nella sezione Mathematica, grazie a David Carraher per averlo sottolineato). Adesso è anche incredibilmente veloce.

Ecco il codice rientrato con alcuni commenti:

Image[1-Thread@IntegerDigits[   (* 3. Convert each number to padded binary, transpose
                                      invert colours, and render as Image. *)
    l = Round[
      (#+3#~Mod~2)^2/48
    ] & /@ Range@##,            (* 1. Turn input into a range and get the Alcuin
                                      number for each element. *)
    2,
    ⌈2~Log~Max@l⌉               (* 2. Determine the maximum number of binary digits. *)
]] &

Ecco l'output per 0, 600:

CJam ( 56 55 53 caratteri) / GolfScript (64 caratteri)

CJam:

"P1"q~,>{_1&3*+_*24+48/}%_:e>2b,\2_$#f+2fbz(,@@:~~]N*

GolfScript:

"P1"\~,>{.1&3*+.*24+48/}%.$-1=2base,\{2.$?+2base}%zip(,@@{~}/]n*

Entrambi producono output in formato NetPBM e sono essenzialmente porte l'una dell'altra.

Dissezione

CJam                 GolfScript           Explanation

"P1"                 "P1"\                NetPBM header
q~,>                 ~,>                  Create array [m .. n-1]
{_1&3*+_*24+48/}%    {.1&3*+.*24+48/}%    Map the sequence calculation
_:e>2b,\             .$-1=2base,\         Compute image height H as highest bit
                                          in largest number in sequence
2_$#f+2fb            {2.$?+2base}%        Map sequence to bits, ensuring that
                                          each gives H bits by adding 2^H
z(,@@                zip(,@@              Transpose and pull off dummy row to use
                                          its length as the "width" in the header
:~~                  {~}/                 Flatten double array and dump on stack
]N*                  ]n*                  Separate everything with whitespace

Grazie a Optimizer per CJam 56 -> 53.

Pyth - 101 60 59

Uscite a .pbm. Probabilmente si può giocare a golf di più.

Km.B/++24*dd**6%d2d48rvzQJCm+*\0-eSmlkKlddK"P1"lhJlJjbmjbdJ

Altamente ungolfed perché tradurrò in Pyth.

Spiegazione che verrà dopo. In questo momento guarda il codice Python equivalente.

Utilizza l'algoritmo OEIS per calcolare la sequenza, quindi converte in binario, inserisce i numeri, esegue una rotazione della matrice e la formatta in pbmun'immagine. Dal momento che non sto usando la forza bruta, è incredibilmente veloce.

         K=
 m          rvzQ      Map from eval input to eval input
  .B                  Binary rep
   /      48          Divided by 48
    ++                Triple sum      
     24               Of 24,
     *dd              Square of d
     **               Triple product
      6               6
      %d2             Modulo d%2
      d               Var d
J                     Set J=
 C                    Matrix rotation from columns of row to rows of columns
  m           K       Map K (This does padding)
   +                  String concat
    *                 String repeat
     \0               "0"
     -     ld         Subtract the length of the column from
      eS              The max
       mlkK           Of all the column lengths
    d                 The column
"P1"                  Print header "P1"
l                     Length of
 hJ                   First row
lJ                    Number of columns
jb                    Join by linebreaks
 m  J                 Map on to J
  jb                  Joined columns by linb
   d

Ecco l' 600,900esempio:

Provalo qui online .

R - 127 125

Non sono sicuro che ciò rispetti totalmente le regole. Non genera un'immagine in un file, ma crea un raster e lo stampa su un dispositivo di output.

Ho trovato la stessa formula di Martin, ma qui .

Utilizza una funzione senza nome.

require(raster);function(m,n)plot(raster(mapply(function(n)rev(as.integer(intToBits(round((n+n%%2*3)^2/48)))),m:n),0,n,0,32))

Esegui come segue

require(raster);(function(m,n)plot(raster(mapply(function(n)rev(as.integer(intToBits(round((n+n%%2*3)^2/48)))),m:n),0,n,0,32)))(0,600)

Produce il seguente diagramma

Python 2 + PIL , 255 184

La mia prima versione utilizzava PIL per mostrare un'immagine:

i,R,B=input,range,lambda x:bin((x*x+6*x*(x%2)+24)/48)[2:]
def F(k,v):i.load()[k]=v
a,b=i(),i();h=len(B(b));from PIL import Image;i=Image.new('P',(b-a,h))
[F((x-a,y),int(B(x).zfill(h)[y])) for x in R(a,b) for y in R(h)]
i.putpalette([255]*3+[0]*3)
i.show()

La nuova versione produce solo un'immagine PPM in bianco e nero su stdout:

i,R,B=input,range,lambda x:bin((x*x+6*x*(x%2)+24)/48)[2:]
def p(s):print s
a,b=i(),i();h=len(B(b));p('P1 %i %i'%(b-a,h))
[p(' '.join([B(x).zfill(h)[y] for x in R(a,b)])) for y in R(h)]

JAVASCRIPT - 291

Codice:

(function(a,b,c){c.width=b;t=c.getContext('2d');t.strokeStyle='black';for(i=a;i<=b;i++){g=(Math.floor(((i*i)+6*i*(i%2)+24)/48)>>>0).toString(2);l=g.length;for(j=0;j<l;j++){if(g[l-1-j]=='1'){t.rect(i-a,j,1,1);t.fill();}}}document.body.appendChild(c);})(0,300,document.createElement('canvas'))

Spiegazione:

(function (a, b, c) {
    //setting canvas width
    c.width = b;
    //get context 2d of canvas
    t = c.getContext('2d');
    //setting storke style.
    t.strokeStyle = 'black';
    //looping from a to b
    for (i = a; i <= b; i++) {
        //calculating A(i) and converting it to a binary string
        g = (Math.floor(((i * i) + 6 * i * (i % 2) + 24) / 48) >>> 0).toString(2);
        //looping through that string
        for (j = 0; j < g.length; j++) {
            //since canvas is upside down and the first digit is actually the last digit:
            if (g[g.length - 1 - j] == '1') {
                //we create the 1 by 1 rect
                t.rect(i - a, j, 1, 1);
                //we draw the rect
                t.fill();
            }
        }
    }
    //we append everything to the body
    document.body.appendChild(c);
    //parameters are put here
})(0, 300, document.createElement('canvas'))

Risultato:

Sì, il risultato è capovolto, ma è perché 0,0in a js canvasè in alto a sinistra. : 3

demo:

Demo su jsfiddle