Ihr Ziel ist es, eine Fibonacci-Spirale mit Zahlen zu erzeugen .

Probe

Beispiel Eingabe / Ausgabe

1 -> 1

2 -> 1 1

3 -> 1 1
     2 2
     2 2

6 -> 8 8 8 8 8 8 8 8 5 5 5 5 5
     8 8 8 8 8 8 8 8 5 5 5 5 5
     8 8 8 8 8 8 8 8 5 5 5 5 5
     8 8 8 8 8 8 8 8 5 5 5 5 5
     8 8 8 8 8 8 8 8 5 5 5 5 5
     8 8 8 8 8 8 8 8 1 1 3 3 3
     8 8 8 8 8 8 8 8 2 2 3 3 3
     8 8 8 8 8 8 8 8 2 2 3 3 3

Eingabe von 9

Eingabe Die Eingabe kann über STDIN oder ein Funktionsargument erfolgen. Es wird eine einzelne Nummer sein

Ausgabe Die Ausgabe kann von STDOUT oder dem Rückgabewert einer Funktion stammen. Es sollte eine einzelne Zeichenfolge sein.

Zusätzliches Leerzeichen am Ende der Zeile ist nicht zulässig. Die Ausgabe kann Ziffern, Zeilenumbrüche (Newlines) und Leerzeichen enthalten.

Orientierung spielt keine Rolle, das bedeutet Rotationen und Reflexionen. Solange es einem gültigen Fibonacci-Spiralmuster folgt.

Zahlen mit unterschiedlich vielen Ziffern (z. B. 1 und 13) sollten rechtsbündig sein. Möglicherweise muss am Anfang einer Zeile ein Leerzeichen eingefügt werden, damit alles in einer Reihe steht.

1   1                          1   1
100 100  should actually be  100 100

Sie können hier ein Beispiel sehen

Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes!

code-golf fibonacci Downgoat
quelle

4

Verwandte Herausforderung (und eine sehr coole Uhr)

Sp3000

Numbers with different amounts of digits (e.g. 1 and 13) should be aligned to the left side of the digit a space may need to be added to the very beginning of a line so everything can line up.

Das klingt so, als ob es klarer als zwei Sätze wäre.

Trichoplax

Aus den Beispielen geht hervor, dass die am weitesten rechts stehende Ziffer jeder Zahl ausgerichtet werden soll, "jedoch an der linken Seite der Ziffer ausgerichtet" wie das Gegenteil klingt.

Trichoplax

Können Sie klarstellen, dass Leerzeichen in der Umgebung nicht zulässig sind? Insbesondere - ist Leerzeichen vor oder hinter den Zeilen akzeptabel?

MtnViewMark

Matlab druckt die Ausgabe standardmäßig auf Standardausgabe. Ist es akzeptabel, eine numerische Ausgabe zu haben (im Gegensatz zu einer Ausgabe vom Typ String), die automatisch auf stdout gedruckt wird?

Luis Mendo

15

APL, 23

{a,⍴⍨2⍴⊃⍴a←⌽⍉⍵}⍣(⎕-1)⍪1

Erläuterung:

⍪1               this creates a 1x1 matrix containing just 1
{..}⍣(⎕-1)     the power operator (⍣) repeats the function {} user input - 1 times
a,⍴⍨2⍴⊃⍴a←⌽⍉⍵   the function being iterated rotates the matrix and appends the next matrix to it.

Probieren Sie es auf tryapl.org

Moris Zucca
quelle

1

Wenn Sie hier suchen, hatten viele Ihre Zweifel vor. Hier ist zum Beispiel die Antwort von @Tobia: * Dyalog APL unterstützt einen älteren Zeichensatz, bei dem die APL-Symbole den oberen 128-Byte-Werten zugeordnet sind. Daher kann ein APL-Programm, das nur ASCII-Zeichen und APL-Symbole verwendet, als Byte == Zeichen betrachtet werden.

Moris Zucca

Okay, dann werde ich meinen Kommentar zurückziehen.

Gar

1

@MorisZucca Beachten Sie jedoch, dass einige Zeichen (wie ⌸oder ⍤) in diesem Zeichensatz fehlen und nicht verwendet werden können, wenn Sie diese Regel aufrufen möchten.

FUZxxl

1

Richtig, "key" und "rank" sind neuere Implementierungen und existieren tatsächlich nur in der Unicode-Version des von mir verwendeten Dyalog-Interpreters. Die Classic-Version muss das equivalentBefehlsäquivalent verwenden. Gleiches gilt beispielsweise auch für ⍠ (⎕OPT). Daher denke ich normalerweise, wenn ich es in der Dyalog Classic-Version schreiben kann, kann man mit Sicherheit sagen, dass es 1 Byte pro Zeichen ist. Korrigiere mich, wenn ich falsch liege. Und danke für den Kommentar.

Moris Zucca

8

Matlab, 84 Bytes

Eine Funktion wird verwendet. Die Ausgabe erfolgt in Standardausgabe.

function f(N)
s=0;t=1;y=1;for n=2:N
u=s+t;s=t;t=u;y=[rot90(y) t*ones(t)];end;disp(y)

Beispiele:

>> f(1)
     1
>> f(2)
     1     1
>> f(3)
     1     2     2
     1     2     2
>> f(6)
     5     5     5     5     5     8     8     8     8     8     8     8     8
     5     5     5     5     5     8     8     8     8     8     8     8     8
     5     5     5     5     5     8     8     8     8     8     8     8     8
     5     5     5     5     5     8     8     8     8     8     8     8     8
     5     5     5     5     5     8     8     8     8     8     8     8     8
     3     3     3     1     1     8     8     8     8     8     8     8     8
     3     3     3     2     2     8     8     8     8     8     8     8     8
     3     3     3     2     2     8     8     8     8     8     8     8     8
>> f(7)
     8     8     8     8     8     8     8     8    13    13    13    13    13    13    13    13    13    13    13    13    13
     8     8     8     8     8     8     8     8    13    13    13    13    13    13    13    13    13    13    13    13    13
     8     8     8     8     8     8     8     8    13    13    13    13    13    13    13    13    13    13    13    13    13
     8     8     8     8     8     8     8     8    13    13    13    13    13    13    13    13    13    13    13    13    13
     8     8     8     8     8     8     8     8    13    13    13    13    13    13    13    13    13    13    13    13    13
     8     8     8     8     8     8     8     8    13    13    13    13    13    13    13    13    13    13    13    13    13
     8     8     8     8     8     8     8     8    13    13    13    13    13    13    13    13    13    13    13    13    13
     8     8     8     8     8     8     8     8    13    13    13    13    13    13    13    13    13    13    13    13    13
     5     5     5     5     5     1     2     2    13    13    13    13    13    13    13    13    13    13    13    13    13
     5     5     5     5     5     1     2     2    13    13    13    13    13    13    13    13    13    13    13    13    13
     5     5     5     5     5     3     3     3    13    13    13    13    13    13    13    13    13    13    13    13    13
     5     5     5     5     5     3     3     3    13    13    13    13    13    13    13    13    13    13    13    13    13
     5     5     5     5     5     3     3     3    13    13    13    13    13    13    13    13    13    13    13    13    13

Matlab, 78 Bytes

function y=f(N)
s=0;t=1;y=1;for n=2:N
u=s+t;s=t;t=u;y=[rot90(y) t*ones(t)];end

Dasselbe wie oben, außer dass die Funktion eines Matlab ausgenutzt wird, nämlich, dass die Funktionsausgabe (als Zeichenfolge) automatisch in stdout angezeigt wird. Dies vermeidet die Umwandlung in einen String bei dem obigen Ansatz.

f(6)
ans =
     5     5     5     5     5     8     8     8     8     8     8     8     8
     5     5     5     5     5     8     8     8     8     8     8     8     8
     5     5     5     5     5     8     8     8     8     8     8     8     8
     5     5     5     5     5     8     8     8     8     8     8     8     8
     5     5     5     5     5     8     8     8     8     8     8     8     8
     3     3     3     1     1     8     8     8     8     8     8     8     8
     3     3     3     2     2     8     8     8     8     8     8     8     8
     3     3     3     2     2     8     8     8     8     8     8     8     8

Luis Mendo
quelle

Ich bin froh, einige Matlab-Lösungen zu sehen :-)

Hoki

@Hoki Danke! :-)

Luis Mendo

7

Python 2, 121 Bytes

a,b=0,1;L=[]
exec"a,b=b,a+b;L=zip(*L[::-1])+[[a]*a]*a;"*input()
for r in L:print" ".join("%*d"%(len(str(a)),x)for x in r)

Die lockeren Regeln für Rotationen machen dies viel einfacher.

Ich habe keine Backticks anstelle von str(a)hier verwendet, weil ich nicht sicher bin, ob wir mehr führende Leerzeichen als nötig haben, wenn wir jemals Longs erreichen. Obwohl, selbst wenn wir es awären, wäre die Nutzung selbst sowieso kürzer.

Sp3000
quelle

7

Ruby, 243 242 236 233 222 170 130 Bytes

s,l,r=0,1,[]
gets.to_i.times{s+=l
l=s-l
s.times{r<<[s]*s}
r=r.transpose.reverse}
r.map{|w|puts w.map{|c|"%#{s.to_s.size}s"%c}*" "}

addison
quelle

1

Schönes Golfen! Sie können einige Zeichen in Zeile 4 speichern, indem Sie t==valueBedingungen in konvertieren t>value. Zum Beispiel(t=x%4)>2?s.times{r<<[s]*s}:t>1?s.times{r.map!{|w|w.unshift s}}:t>0?s.times{r.unshift [s]*s}:r.map!{|w|w+=[s]*s}}

Cristian Lupascu

6

Python - 189 179 174

n=int(input())
f=[1,1]
while len(f)<n:f+=[f[-1]+f[-2]]
o=[[]]
for i in f:o=(list(zip(*o)))[::-1]+[[i]*i]*i
for x in o:print(' '.join(str(y).rjust(len(str(f[-1])))for y in x))

faubi
quelle

6

J, 36 Bytes

1&(($~,~)@(1{$@]),.|:@|.@])&(,.1)@<:

Verwendung:

   (1&(($~,~)@(1{$@]),.|:@|.@])&(,.1)@<:) 6
8 8 8 8 8 8 8 8 5 5 5 5 5
8 8 8 8 8 8 8 8 5 5 5 5 5
8 8 8 8 8 8 8 8 5 5 5 5 5
8 8 8 8 8 8 8 8 5 5 5 5 5
8 8 8 8 8 8 8 8 5 5 5 5 5
8 8 8 8 8 8 8 8 1 1 3 3 3
8 8 8 8 8 8 8 8 2 2 3 3 3
8 8 8 8 8 8 8 8 2 2 3 3 3

Methode:

Die Funktion dreht das aktuelle Quadrat und fügt das neue Quadrat einmal zum aktuellen hinzu input-1. Quadratgröße und Elementwerte werden aus der Größe des vorherigen Rechtecks ermittelt.

Code Erklärung:

1&(           loop
    ($~,~)      new square with size and elements
    @(1{$@])    with the size of the second dimension of the current rectangle
    ,.          attached to
    |:@|.@]     rotated current rectangle
)&(,.1)       starting the loop with matrix 1
@<:           looping input-1 times

Probieren Sie es hier online aus.

randomra
quelle

6

Haskell, 183 176 171 163 Bytes

import Data.List
s t=map((t>>[l t])++)t
e 1=[[1]];e n=s.reverse.transpose$e$n-1
f=g.e
g m=unlines$map(>>=((show$l m)#).show)m
a#b|l a<l b=b;a#b=a#(' ':b)
l=length

Die Funktion ist f, die eine Zahl annimmt und eine einzelne Zeichenkette zurückgibt:

λ: putStr $ f 8
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21  5  5  5  5  5  8  8  8  8  8  8  8  8
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21  5  5  5  5  5  8  8  8  8  8  8  8  8
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21  5  5  5  5  5  8  8  8  8  8  8  8  8
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21  5  5  5  5  5  8  8  8  8  8  8  8  8
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21  5  5  5  5  5  8  8  8  8  8  8  8  8
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21  3  3  3  1  1  8  8  8  8  8  8  8  8
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21  3  3  3  2  2  8  8  8  8  8  8  8  8
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21  3  3  3  2  2  8  8  8  8  8  8  8  8
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 13 13 13 13 13 13 13 13 13 13 13 13 13
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 13 13 13 13 13 13 13 13 13 13 13 13 13
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 13 13 13 13 13 13 13 13 13 13 13 13 13
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 13 13 13 13 13 13 13 13 13 13 13 13 13
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 13 13 13 13 13 13 13 13 13 13 13 13 13
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 13 13 13 13 13 13 13 13 13 13 13 13 13
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 13 13 13 13 13 13 13 13 13 13 13 13 13
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 13 13 13 13 13 13 13 13 13 13 13 13 13
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 13 13 13 13 13 13 13 13 13 13 13 13 13
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 13 13 13 13 13 13 13 13 13 13 13 13 13
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 13 13 13 13 13 13 13 13 13 13 13 13 13
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 13 13 13 13 13 13 13 13 13 13 13 13 13
 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 13 13 13 13 13 13 13 13 13 13 13 13 13

MtnViewMark
quelle

5

Pyth, 34 Bytes

jbmsm.[hl`lhZ`k\ d=Zu+_CGmmlGGGQ]]

Überraschenderweise wird mehr als die Hälfte des Codes gedruckt / aufgefüllt, anstatt die Matrix zu generieren.

Die Erzeugung der Matrix ist wirklich einfach, sie besteht jedoch aus einer Transponierung und Umkehrung sowie dem Hinzufügen von N Zeilen, die N Kopien von N enthalten, wobei N die aktuelle Anzahl von Zeilen ist.

Beispielausgabe für 7:

  5  5  5  5  5  8  8  8  8  8  8  8  8
  5  5  5  5  5  8  8  8  8  8  8  8  8
  5  5  5  5  5  8  8  8  8  8  8  8  8
  5  5  5  5  5  8  8  8  8  8  8  8  8
  5  5  5  5  5  8  8  8  8  8  8  8  8
  3  3  3  1  1  8  8  8  8  8  8  8  8
  3  3  3  2  2  8  8  8  8  8  8  8  8
  3  3  3  2  2  8  8  8  8  8  8  8  8
 13 13 13 13 13 13 13 13 13 13 13 13 13
 13 13 13 13 13 13 13 13 13 13 13 13 13
 13 13 13 13 13 13 13 13 13 13 13 13 13
 13 13 13 13 13 13 13 13 13 13 13 13 13
 13 13 13 13 13 13 13 13 13 13 13 13 13
 13 13 13 13 13 13 13 13 13 13 13 13 13
 13 13 13 13 13 13 13 13 13 13 13 13 13
 13 13 13 13 13 13 13 13 13 13 13 13 13
 13 13 13 13 13 13 13 13 13 13 13 13 13
 13 13 13 13 13 13 13 13 13 13 13 13 13
 13 13 13 13 13 13 13 13 13 13 13 13 13
 13 13 13 13 13 13 13 13 13 13 13 13 13
 13 13 13 13 13 13 13 13 13 13 13 13 13

orlp
quelle

4

Perl, 289 277 257 Bytes

@f=(0,1);push@f,$f[-1]+$f[-2]while(@f<=$ARGV[0]);$d=1+length$f[-1];shift@f;map{$v=$f[$_];$t=sprintf("%${d}d",$v)x$v;$_%4||map{unshift@s,$t}1..$v;$_%4==3&&map{$_.=$t}@s;$_%4==2&&map{push@s,$t}1..$v;$_%4==1&&map{$_=$t.$_}@s;}0..$#f;$\=$/;for(@s){s/^ //;print}

Ruth Franklin
quelle

4

K, 48 Bytes

{{`0:1_',/'(1+#$|//x)$x}(x-1){+|x,\:t#t:#x}/,,1}

Und in Aktion:

  {{`0:1_',/'(1+#$|//x)$x}(x-1){+|x,\:t#t:#x}/,,1}7
 8  8  8  8  8  8  8  8  5  5  5  5  5
 8  8  8  8  8  8  8  8  5  5  5  5  5
 8  8  8  8  8  8  8  8  5  5  5  5  5
 8  8  8  8  8  8  8  8  5  5  5  5  5
 8  8  8  8  8  8  8  8  5  5  5  5  5
 8  8  8  8  8  8  8  8  1  1  3  3  3
 8  8  8  8  8  8  8  8  2  2  3  3  3
 8  8  8  8  8  8  8  8  2  2  3  3  3
13 13 13 13 13 13 13 13 13 13 13 13 13
13 13 13 13 13 13 13 13 13 13 13 13 13
13 13 13 13 13 13 13 13 13 13 13 13 13
13 13 13 13 13 13 13 13 13 13 13 13 13
13 13 13 13 13 13 13 13 13 13 13 13 13
13 13 13 13 13 13 13 13 13 13 13 13 13
13 13 13 13 13 13 13 13 13 13 13 13 13
13 13 13 13 13 13 13 13 13 13 13 13 13
13 13 13 13 13 13 13 13 13 13 13 13 13
13 13 13 13 13 13 13 13 13 13 13 13 13
13 13 13 13 13 13 13 13 13 13 13 13 13
13 13 13 13 13 13 13 13 13 13 13 13 13
13 13 13 13 13 13 13 13 13 13 13 13 13

Kann noch einige gute Möglichkeiten zum Golfen sein.

Das Programm besteht im Wesentlichen aus zwei Teilen: der Generierung der verketteten Matrix und der Formatierung für die Ausgabe. Ersteres ist ziemlich einfach:

  {(x-1){+|x,\:t#t:#x}/,,1}5
(3 3 3 2 2
 3 3 3 2 2
 3 3 3 1 1
 5 5 5 5 5
 5 5 5 5 5
 5 5 5 5 5
 5 5 5 5 5
 5 5 5 5 5)

Erstellen Sie ausgehend von einer 1x1-Matrix mit 1 einen T-Längenvektor von T, wobei T die Länge der Startmatrix in der ersten Dimension ( t#t:#x) ist, und hängen Sie diese an jede Zeile der Originalmatrix ( x,\:) an. Wenn Sie das Ergebnis umkehren und transponieren ( +|), wird es um 90 Grad gedreht. Wir machen das N-1 mal.

Die Formatierung ist ziemlich umständlich, da K beim Drucken einer Matrix die Anzahl der Spalten nicht so ausrichtet, wie wir es benötigen:

{`0:1_',/'(1+#$|//x)$x}

Die Grundidee ist, das maximale Element der Matrix ( |//x) zu nehmen, es in einen String (unär $) umzuwandeln , seine Länge plus eins ( 1+#) zu nehmen und dann die Elemente der Matrix zu rechts ausgerichteten Strings dieser Größe zu formatieren. Verbinden Sie dann zum Aufräumen diese Zeichenfolgen ( ,/') und löschen Sie das resultierende führende Leerzeichen ( 1_').

JohnE
quelle

4

CJam, 48 Bytes

1saali({z{W%}%_0=,__sa*a*+}*_W=W=,):U;{USe[}f%N*

Probieren Sie es online aus

Der Kern der Erstellung des Musters scheint ziemlich einfach zu sein. Drehen Sie das bisher erstellte Rechteck und fügen Sie unten ein Quadrat mit Werten hinzu.

Der Code zum Auffüllen des Ergebnisses sieht jedoch schrecklich aus. Ich habe eine Reihe von Kombinationen von fund :Operatoren ausprobiert , um die Auffüllung auf die verschachtelte Liste anzuwenden, aber nichts hat funktioniert. Wenn jemand bessere Vorschläge hat, sind sie herzlich willkommen.

1s    First value. Using string for values so that we can pad them in the end.
aa    Wrap it twice. Data on stack will be a list of lists (list of lines).
li    Get input.
(     Decrement, since we seeded the list at n=1.
{     Loop over n.
  z     Transpose...
  {W%}% ... and reverse all lines, resulting in a 90 degree rotation.
  _0=,  Get length of line, which is the size of square we need to add.
  __    Create two copies of size.
  sa    Convert one size to string, and wrap it in array.
  *     Replicate it size times. This is one line.
  a     Wrap the line...
  *     ... and replicate it size times. The square of new values is done.
  +     Add the list of lines to the previous list of lines.
}*    End of loop over n.
_W=W= Get last value produced.
,)    Take its length, and increment it. This is the output field width.
:U;   Store the field width in variable, and pop it. This is ugly.
{     Start of block applied to all values.
  U     Field width stored in variable.
  S     Space.
  e[    Pad left.
}f%   End of block applied to all values.
N*    Join lines with newline.

Reto Koradi
quelle

Das Umkehren aller Zeilen kann mit erfolgen Wf%. Würdest du auch etwas tun können {Se[}ff%anstatt :U;{USe[}f%für die Polsterung? (Das könnte nicht so funktionieren wie es ist, ich kann es

momentan

2

Pyth, 29 Bytes

Vu+C_GmmlGGGQ\]Yjdm.\[l`lN`d\ N

Demonstration.

Wenn das Auffüllen wie in APL frei / implizit war oder die Matrixausgabe zulässig war, wären dies 14 Byte:

u+C_GmmlGGGQ]Y

isaacg
quelle

2

Ruby, 129 Bytes

Ich habe die andere Ruby-Antwort ein paar Mal bearbeitet, aber meine letzte Änderung wird nicht akzeptiert oder so, also hier ist es:

s,r=0,[[1]]
gets.to_i.times{s+=r[0][0]
r=(r+[[s]*s]*s).transpose.reverse}
r.map{|w|puts w.map{|c|"%#{r[0][s].to_s.size}s"%c}*' '}

user2251284
quelle

1

Willkommen bei PPCG! Golfverbesserungen werden normalerweise hier abgelehnt (wenn Ihre anderen Vorschläge akzeptiert wurden, die ein Versehen gewesen sein müssen), weil sie in Kommentaren veröffentlicht werden sollen, damit der Autor sie überprüfen kann. In diesem Meta-Post finden Sie die Gründe für diese Richtlinie.

Martin Ender

Danke für die Info, macht Sinn. Das Kommentieren ist das, was ich ursprünglich getan hätte, aber ich hatte nicht genug Reputationspunkte, um es zu kommentieren, aber ich werde es in Zukunft tun. Viel Spaß beim Golfen!

user2251284

1

ES6, 248 Bytes

n=>(f=(n,o=n)=>Array(n).fill(o),g=n=>n<3?[f(n,1)]:(a=g(n-2)).reverse().concat(f(l=a[0].length,f(l))).map((e,i,a)=>f(a.length).concat(e.reverse())),a=g(n),s=' '.repeat(l=` ${a[0][0]}`.length),a.map(a=>a.map((e,i)=>(s+e).slice(!i-1)).join``).join`\n`)

Wobei \nein buchstäbliches Newline-Zeichen darstellt.

Ärgerlicherweise nimmt die Formatierung einen großen Teil des Codes ein.

fist eine Hilfsfunktion, die ein gefülltes Array erstellt. Es wird hauptsächlich zum Erstellen der ausgefüllten Quadrate verwendet, verdoppelt sich aber auch leicht, um die Basisfälle für die Rekursion zu erstellen.

gist das Hauptproblem. Es generiert rekursiv die vorletzte Lösung, dreht sie um 180 Grad und hängt dann die nächsten beiden Quadrate an.

Neil
quelle

Fibonacci-Spirale