Meine Herausforderungen sind in der Regel etwas schwierig und unattraktiv. Also hier etwas einfaches und lustiges.

Alcuins Sequenz

Alcuins Sequenz A(n) wird durch Zählen von Dreiecken definiert. A(n)ist die Anzahl der Dreiecke mit ganzzahligen Seiten und Umfang n. Diese Sequenz heißt nach Alcuin von York.

Die ersten Elemente dieser Sequenz, beginnend mit n = 0:

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

Zum Beispiel A(9) = 3, weil die einzige Dreiecke mit ganzzahligen Seiten und Umfang 9ist 1 - 4 - 4, 3 - 3 - 3und 2 - 3 - 4. Unten sehen Sie die 3 gültigen Dreiecke.

In dieser Sequenz gibt es einige recht interessante Muster. Zum Beispiel A(2*k) = A(2*k - 3).

Weitere Informationen finden Sie unter A005044 zu OEIS.

Herausforderung

Ihre Herausforderung besteht jedoch in der binären Darstellung dieser Zahlen. Wenn wir jede Sequenznummer in ihre Binärdarstellung umwandeln, sie in Spaltenvektoren einfügen und in einer Linie anordnen, entsteht ein sehr interessantes Binärbild.

Im folgenden Bild sehen Sie die binäre Darstellung der Folgenummern A(0), A(1), ..., A(149). In der ersten Spalte sehen Sie die binäre Darstellung von A(1), in der zweiten Spalte die Darstellung von A(1)und so weiter.

In diesem Bild sehen Sie eine Art sich wiederholendes Muster. Es sieht sogar irgendwie aus wie Fraktale, wenn man sich zum Beispiel das Bild mit den Folgenummern ansieht A(600), A(601), ..., A(899).

Ihre Aufgabe ist es, ein solches Bild zu erzeugen. Ihre Funktion, Ihr Skript wird zwei Ganzzahlen erhalten 0 <= m < n, und es muss das Binärbild von Alcuins Sequenz erzeugen A(m), A(m+1), A(m+2), ..., A(n-2), A(n-1). Der Eingang 0, 150erzeugt also das erste Bild, der Eingang 600, 900das zweite Bild.

Sie können jedes gängige Grafikformat verwenden. Angenommen , jedes Format, das mit image.online-convert.com in png konvertiert werden kann . Alternativ können Sie das Bild auf dem Bildschirm anzeigen. Keine führenden weißen Zeilen erlaubt!

Das ist Code-Golf. So gewinnt der kürzeste Code (in Bytes).

J ( 52 45 (Codepage 437))

Das wäre erlaubt (denke ich)

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

Hex Dump

(Eigentlich nichts Besonderes, das schwarze Quadrat ist DB ₁₆ oder 219 ₁₀ in Codepage 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.)

Verwendung

Dies wird wie folgt ausgegeben (die Code-Tags vermasseln es, indem sie Leerzeichen zwischen den Zeilen einfügen):

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

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

In der Standard-J-Konsole gibt es keinen Zeilenabstand. Daher bezeichne ich die Regel als "Alternativ können Sie das Bild auch auf dem Bildschirm anzeigen." (Nirgends wurde gesagt, dass dieses Bild intern als vernünftiges Bildformat dargestellt werden muss.)

BEARBEITEN: Jconsole (im Gegensatz zu JQT) verwendet standardmäßig die Codepage 437 und gibt die Rechtecke korrekt wieder, wenn sie aus einer Zeichenfolge verwendet werden.

Mathematica, 126 122 121 89 Bytes

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

Dies definiert eine unbenannte Funktion, die die beiden Ganzzahlen als Parameter verwendet und das Bild auf dem Bildschirm anzeigt. Es zeichnet jedes Quadrat als ein einzelnes Pixel auf, aber wenn Sie möchten, können Sie tatsächlich zoomen.

Ich verwende jetzt eine explizite Formel aus dem OEIS-Artikel (die erste im Mathematica-Abschnitt, danke an David Carraher, der darauf hingewiesen hat). Es ist jetzt auch unglaublich schnell.

Hier ist der eingerückte Code mit ein paar Kommentaren:

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. *)
]] &

Hier ist die Ausgabe für 0, 600:

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

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*

Beide erzeugen eine Ausgabe im NetPBM-Format und sind im Wesentlichen Ports voneinander.

Präparation

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

Danke an Optimizer für CJam 56 -> 53.

Pyth - 101 60 59

Ausgänge a .pbm. Kann wahrscheinlich mehr golfen werden.

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

Sehr ungolfed, weil ich nach Pyth übersetzen werde.

Erklärung kommt als nächstes. Schauen Sie sich jetzt den entsprechenden Python-Code an.

Es verwendet den OEIS-Algorithmus, um die Sequenz zu berechnen, und konvertiert dann in Binärdaten, füllt die Zahlen auf, führt eine Matrixrotation durch und formatiert sie in ein pbmBild. Da ich keine rohe Gewalt benutze, ist es unglaublich schnell.

         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

Hier ist das 600,900Beispiel:

Probieren Sie es hier online .

R - 127 125

Ich bin mir nicht sicher, ob dies den Regeln vollständig entspricht. Es wird kein Bild in eine Datei ausgegeben, jedoch ein Raster erstellt und auf einem Ausgabegerät geplottet.

Ich fand die gleiche Formel wie Martin, aber hier .

Es verwendet eine unbenannte Funktion.

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))

Führen Sie wie folgt aus

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)

Erzeugt den folgenden Plot

Python 2 + PIL , 255 184

Meine erste Version verwendete PIL, um ein Bild anzuzeigen:

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()

Die neue Version erzeugt nur ein s / w-PPM-Bild auf 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

Code:

(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'))

Erläuterung:

(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'))

Ergebnis:

Ja, das Ergebnis ist verkehrt herum, aber das liegt daran, dass 0,0a js canvasoben links ist. :3

Demo:

Demo auf jsfiddle