Spirale de Fibonacci

37

Votre objectif est de générer une spirale de Fibonacci avec des nombres.

Échantillon

Exemple d'entrée / sortie

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

Entrée de 9

Entrée L'entrée peut être prise via STDIN ou un argument de fonction. Ce sera un numéro unique

Sortie La sortie peut provenir de STDOUT ou de la valeur de retour d'une fonction. Ce devrait être une seule chaîne.

Les espaces supplémentaires à la fin de la ligne ne sont pas autorisés. La sortie peut contenir des chiffres, des sauts de ligne (nouvelles lignes) et des espaces.

L'orientation n'a pas d'importance, cela signifie des rotations et des réflexions. Tant qu'il suit un modèle de spirale de Fibonacci valide.

Les nombres avec différentes quantités de chiffres (par exemple 1 et 13) doivent être alignés à droite. Il peut être nécessaire d'ajouter un espace au tout début d'une ligne pour que tout puisse s'aligner.

1   1                          1   1
100 100  should actually be  100 100

Vous pouvez voir un exemple ici

C'est du code-golf, donc le code le plus court en octets gagne!

code-golf fibonacci Downgoat
la source
4
Défi lié (et une horloge très cool)
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.Cela semble être plus clair en deux phrases.
Trichoplax
D'après les exemples, il semblerait que vous souhaitiez aligner le chiffre le plus à droite de chaque chiffre, mais "aligner à gauche du chiffre" sonne comme le contraire.
Trichoplax
Pouvez-vous clarifier "les espaces blancs environnants ne sont pas autorisés"? En particulier - les espaces de début ou de fin sur les lignes sont-ils acceptables?
MtnViewMark
Matlab imprime la sortie sur stdout par défaut. Est-il acceptable d'avoir une sortie de type numérique (par opposition à une sortie de type chaîne) qui soit automatiquement imprimée sur la sortie standard?
Luis Mendo

Réponses:

15

APL, 23

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

Explication:

⍪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.

Essayez-le sur tryapl.org

Moris Zucca
la source
1
Si vous recherchez ici, beaucoup ont déjà eu votre doute. Voici par exemple la réponse de @Tobia: * Dyalog APL prend en charge un jeu de caractères hérité dans lequel les symboles APL sont mappés sur les valeurs supérieures à 128 octets. Par conséquent, un programme APL qui utilise uniquement des caractères ASCII et des symboles APL peut être considéré comme un octet == caractères.
Moris Zucca
Bon alors, je vais retirer mon commentaire.
Gar
1
@ MorisZucca Notez cependant que certains personnages (comme ⌸ou⍤ ) sont absents de ce jeu de caractères et ne peuvent pas être utilisés pour évoquer cette règle.
FUZxxl
1
Certes, "clé" et "rang" sont des implémentations plus récentes et n'existent en fait que dans la version Unicode de l'interpréteur Dyalog que j'utilise. La version Classic doit utiliser l'équivalent de la commande. La même chose s'applique à ⍠ (⎕OPT) aussi, par exemple. Ainsi, je pense généralement que si je peux l'écrire dans la version Dyalog Classic, il est prudent de dire que c'est un octet par caractère. Corrige moi si je me trompe. Et merci pour le commentaire.
Moris Zucca
8

Matlab, 84 octets

Une fonction est utilisée. La sortie est en stdout.

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)

Exemples:

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

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

Idem que ci-dessus, sauf qu'une fonctionnalité de Matlab est exploitée, à savoir qu'elle affiche automatiquement la sortie de la fonction (sous forme de chaîne) dans stdout. Cela évite la conversion en chaîne dans l'approche ci-dessus.

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
la source
heureux de voir des solutions Matlab :-)
Hoki
@Hoki Merci! :-)
Luis Mendo
7

Python 2, 121 octets

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)

Les règles assouplies sur les rotations rendent cela beaucoup plus simple.

Je n'ai pas utilisé de backtick à la place d' str(a)ici parce que je ne suis pas sûr que nous puissions avoir plus de places de premier plan que nécessaire, si jamais nous atteignons des longs. Même si, même si c'était le cas, son utilisation aserait de toute façon plus courte.

Sp3000
la source
7

Ruby, 243 242 236 233 222 170 130 octets

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
la source
1
Beau golf! Vous pouvez enregistrer certains caractères sur la ligne 4 en convertissant les t==valueconditions en t>value. Par exemple,(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 le
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
la source
6

J, 36 octets

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

Usage:

   (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

Méthode:

La fonction fait pivoter le carré actuel et ajoute le nouveau carré au carré actuel. input-1 . La taille des carrés et les valeurs des éléments proviennent de la taille du rectangle précédent.

Explication du code:

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

Essayez-le en ligne ici.

randomra
la source
6

Haskell, 183 176 171 163 octets

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

La fonction est f, qui prend un nombre et retourne une seule chaîne:

λ: 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
la source
5

Pyth, 34 octets

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

Étonnamment, plus de la moitié du code est imprimé / rempli, plutôt que de générer la matrice.

La génération de la matrice est très simple, cependant, elle consiste en une transposition et une inversion, et en ajoutant N lignes contenant N copies de N, N étant le nombre actuel de lignes.

Exemple de sortie pour 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
la source
4

Perl, 289 277 257 octets

@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
la source
4

K, 48 octets

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

Et en action:

  {{`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

Peut-être encore de bonnes opportunités pour le golf.

Le programme consiste essentiellement en deux parties: générer la matrice concaténée et la formater pour la sortie. Le premier est assez simple:

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

En commençant par une matrice 1x1 contenant 1, créez un vecteur de longueur T de T, où T est la longueur de la matrice de départ sur la première dimension ( t#t:#x) et attachez-le à chaque ligne de la matrice d'origine ( x,\:). Inverser et transposer le résultat ( +|) le fait pivoter de 90 degrés. Nous faisons cela N-1 fois.

Le formatage est assez maladroit, car l'approche naturelle de K pour imprimer une matrice ne permet pas d'aligner les colonnes de chiffres comme nous en avons besoin:

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

L'idée de base est de prendre l'élément maximum de la matrice ( |//x), de la convertir en chaîne (unaire $), de prendre sa longueur plus un ( 1+#), puis de formater les éléments de la matrice en chaînes alignées à droite de cette taille. Ensuite, pour ranger, joignez ces chaînes ( ,/') et supprimez l’espace résultant ( 1_').

JohnE
la source
4

CJam, 48 octets

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

Essayez-le en ligne

La partie essentielle de la génération du motif semble relativement simple. Faites pivoter le rectangle créé jusqu'à présent et ajoutez un carré de valeurs en bas.

Le code pour le remplissage du résultat est affreux, cependant. J'ai essayé un tas de combinaisons de fet :opérateurs pour appliquer le remplissage à la liste imbriquée, mais rien n'a fonctionné. Si quelqu'un a de meilleures suggestions, elles sont les bienvenues.

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
la source
Inverser toutes les lignes peut être fait avec Wf%. Aussi, seriez-vous capable de faire quelque chose comme {Se[}ff%plutôt que :U;{USe[}f%pour le rembourrage? (Cela pourrait ne pas fonctionner comme cela est, je ne peux pas y penser pour le moment.)
Esolanging Fruit
2

Pyth, 29 octets

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

Manifestation.

Si le remplissage était libre / implicite, comme dans APL, ou si la sortie de matrice était autorisée, il s'agirait de 14 octets:

u+C_GmmlGGGQ]Y
isaacg
la source
2

Ruby, 129 octets

J'ai édité l'autre ruby ​​répondre à un tas, mais mon dernier changement n'est pas accepté ou quelque chose, alors le voici:

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}*' '}
utilisateur2251284
la source
1
Bienvenue chez PPCG! Les améliorations apportées au golf sont généralement rejetées ici (si vos autres suggestions ont été acceptées, cela doit être un oubli), car elles sont censées être publiées dans des commentaires que l'auteur peut consulter. Voir ce méta post pour le raisonnement derrière cette politique.
Martin Ender
Merci pour l'info, ça a du sens. Commenter est ce que j’aurais fait à l’origine, mais je n’ai pas assez de points de réputation à commenter, mais je le ferai à l’avenir. Bon golf!
user2251284
1

ES6, 248 octets

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

Où \nreprésente un caractère de nouvelle ligne littéral.

Ennuis, la mise en forme occupe une grande partie du code.

fest une fonction d'assistance qui crée un tableau rempli. Il est principalement utilisé pour créer les carrés remplis, mais se double également pour produire les cas de base de la récursivité.

gest le principal gruntwork. Il génère récursivement l'avant dernière solution, la fait pivoter de 180 degrés, puis ajoute les deux carrés suivants.

Neil
la source