Twoim celem jest wygenerowanie spirali Fibonacciego z liczbami.

Próba

Przykład wejścia / wyjścia

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

Wejście 9

Dane wejściowe Dane wejściowe można pobierać za pomocą argumentu STDIN lub funkcji. Będzie to pojedynczy numer

Dane wyjściowe Dane wyjściowe mogą pochodzić z STDOUT lub wartości zwracanej przez funkcję. Powinien to być pojedynczy ciąg.

Dodatkowe białe znaki na samym końcu linii nie są dozwolone. Dane wyjściowe mogą zawierać cyfry, linie (znaki nowego wiersza) i spacje.

Orientacja nie ma znaczenia, oznacza to obroty i odbicia. O ile podąża za prawidłowym wzorem spirali Fibonacciego.

Liczby z różnymi ilościami cyfr (np. 1 i 13) powinny być wyrównane do siebie w prawo. Może być konieczne dodanie spacji na samym początku linii, aby wszystko mogło się wyrównać.

1   1                          1   1
100 100  should actually be  100 100

Można zobaczyć przykład tutaj

To jest golf golfowy, więc wygrywa najkrótszy kod w bajtach!

code-golf fibonacci

— Downgoat
źródło

4

Powiązane wyzwanie (i bardzo fajny zegar)

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

To brzmi jak może być jaśniejsze jako dwa zdania.

— trichoplax

Z przykładów wynika, że chcesz, aby cyfra po prawej stronie każdej liczby była wyrównana, ale „wyrównanie do lewej strony cyfry” brzmi podobnie.

— trichoplax

Czy możesz wyjaśnić, że „otaczanie białych znaków jest niedozwolone”? W szczególności - czy dopuszczalne są wiodące lub końcowe białe spacje na liniach?

— MtnViewMark

Matlab domyślnie drukuje wyjście na standardowe wyjście. Czy dopuszczalne jest posiadanie wyjścia numerycznego (w przeciwieństwie do wyjścia ciągowego), które jest automatycznie drukowane na standardowe wyjście?

— Luis Mendo,

15

APL, 23

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

Wyjaśnienie:

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

Wypróbuj na tryapl.org

— Moris Zucca
źródło

1

Jeśli szukasz tutaj, wiele osób miało wcześniej wątpliwości. Oto na przykład odpowiedź @Tobia: * APL Dyalog obsługuje starszy zestaw znaków, który ma symbole APL odwzorowane na górne 128 bajtów. Dlatego program APL, który używa tylko znaków ASCII i symboli APL, można uznać za bajty == znaków.

— Moris Zucca,

OK, wycofam swój komentarz.

— gar

1

@MorisZucca Zauważ jednak, że niektórych znaków (takich jak ⌸lub ⍤) brakuje w tym zestawie znaków i nie można ich użyć, jeśli chcesz przywołać tę regułę.

— FUZxxl,

1

To prawda, że „key” i „rank” są nowszymi implementacjami i istnieją w rzeczywistości tylko w wersji Unicode interpretera Dyalog, którego używam. Wersja klasyczna musi używać ekwiwalentu polecenia ⎕. To samo dotyczy na przykład ⍠ (⎕OPT). Dlatego zazwyczaj myślę, że jeśli mogę to napisać w wersji Dyalog Classic, można śmiało powiedzieć, że jest to 1 bajt na znak. Popraw mnie, jeśli się mylę. I dzięki za komentarz.

— Moris Zucca

8

Matlab, 84 bajty

Używana jest funkcja. Wyjście jest ustawione na standardowe wyjście.

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)

Przykłady:

>> 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 bajtów

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

To samo co powyżej, z wyjątkiem tego, że funkcja Matlaba jest wykorzystywana, mianowicie automatycznie wyświetla wyjście funkcji (jako ciąg) w standardowym wyjściu. Pozwala to uniknąć konwersji na ciąg znaków w powyższym podejściu.

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
źródło

cieszę się, że widzę rozwiązania Matlaba :-)

— Hoki,

@Hoki Thanks! :-)

— Luis Mendo,

7

Python 2, 121 bajtów

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)

Złagodzone zasady dotyczące rotacji sprawiają, że jest to o wiele prostsze.

Nie użyłem tu backsicków str(a), ponieważ nie jestem pewien, czy wolno nam więcej wiodących pól niż to konieczne, jeśli kiedykolwiek osiągniemy długie. Chociaż nawet gdybyśmy to zrobili, użycie asamego siebie i tak byłoby krótsze.

— Sp3000
źródło

7

Rubinowy, 243 242 236 233 222 170 130 bajtów

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
źródło

1

Miłej gry w golfa! Możesz zapisać niektóre znaki w linii 4, konwertując t==valuewarunki na t>value. Na przykład(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
źródło

6

J, 36 bajtów

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

Stosowanie:

   (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

Metoda:

Funkcja obraca bieżący kwadrat i dodaje nowy kwadrat do prądu jeden input-1raz. Rozmiar kwadratu i wartości elementów są zbierane z wielkości poprzedniego prostokąta.

Objaśnienie kodu:

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

Wypróbuj online tutaj.

— randomra
źródło

6

Haskell, 183 176 171 163 bajtów

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

Ta funkcja fpobiera liczbę i zwraca pojedynczy ciąg znaków:

λ: 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
źródło

5

Pyth, 34 bajty

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

Co zaskakujące, ponad połowa kodu to drukowanie / wypełnianie, a nie generowanie matrycy.

Generowanie macierzy jest naprawdę proste, polega jednak na transpozycji i odwróceniu oraz dodaniu N linii zawierających N kopii N, gdzie N jest bieżącą liczbą linii.

Przykładowe dane wyjściowe dla 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
źródło

4

Perl, 289 277 257 bajtów

@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
źródło

4

K, 48 bajtów

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

I w akcji:

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

Nadal mogą być dobre okazje do gry w golfa.

Program składa się zasadniczo z dwóch części - generowania skonkatowanej macierzy i formatowania jej w celu uzyskania wyniku. Pierwsza jest dość prosta:

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

Zaczynając od macierzy 1x1 zawierającej 1, zbuduj wektor T długości T, gdzie T jest długością macierzy początkowej w pierwszym wymiarze ( t#t:#x) i dołącz ją do każdego rzędu oryginalnej macierzy ( x,\:). Odwrócenie i transpozycja wyniku ( +|) powoduje obrót o 90 stopni. Robimy to N-1 razy.

Formatowanie jest dość niezgrabne, ponieważ naturalne podejście K do drukowania matrycy nie wyrówna kolumn liczbowych tak, jak potrzebujemy:

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

Podstawową ideą jest pobranie maksymalnego elementu macierzy ( |//x), przekonwertowanie go na ciąg (jednoargumentowy $), przyjęcie jego długości plus jeden ( 1+#), a następnie sformatowanie elementów macierzy na wyrównane do prawej ciągi tego rozmiaru. Następnie, aby uporządkować, połącz te ciągi ( ,/') i upuść wynikową spację wiodącą ( 1_').

— JohnE
źródło

4

CJam, 48 bajtów

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

Wypróbuj online

Zasadnicza część generowania wzoru wydaje się dość prosta. Obróć utworzony dotychczas prostokąt i dodaj kwadrat wartości na dole.

Kod wypełniania wyniku wygląda jednak okropnie. Wypróbowałem kilka kombinacji operatorów fi :operatorów, aby zastosować dopełnienie do listy zagnieżdżonej, ale nic nie działało. Jeśli ktoś ma lepsze sugestie, jest bardzo mile widziany.

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
źródło

Można cofnąć wszystkie linie Wf%. Czy byłbyś w stanie zrobić coś takiego {Se[}ff%, jak zamiast :U;{USe[}f%wypełnienia? (To może nie działać tak, jak jest, nie mogę teraz tego przemyśleć.)

— Esolanging Fruit

2

Pyth, 29 bajtów

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

Demonstracja.

Gdyby dopełnienie było dowolne / niejawne, jak w APL lub dozwolone było wyjście macierzy, byłoby to 14 bajtów:

u+C_GmmlGGGQ]Y

— isaacg
źródło

2

Ruby, 129 bajtów

Zredagowałem drugą rubinową odpowiedź, ale moja ostatnia zmiana nie została zaakceptowana, czy coś, więc oto:

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}*' '}

— użytkownik2251284
źródło

1

Witamy w PPCG! Ulepszenia gry w golfa są zwykle odrzucane w tym miejscu (jeśli twoje inne sugestie zostały zaakceptowane, to musiał być przeoczenie), ponieważ powinny być zamieszczane w komentarzach do recenzji przez autora. Zobacz ten meta post dla uzasadnienia tej zasady.

— Martin Ender

Dzięki za informacje, ma sens. Komentowanie jest tym, co pierwotnie zrobiłbym, ale nie miałem wystarczającej liczby punktów reputacji, aby komentować, ale zrobię to w przyszłości. Miłej gry w golfa!

— user2251284 24.07.15

1

ES6, 248 bajtów

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

Gdzie \nreprezentuje dosłowny znak nowej linii.

Irytujące formatowanie zajmuje dużą część kodu.

fto funkcja pomocnicza, która tworzy wypełnioną tablicę. Służy głównie do tworzenia wypełnionych kwadratów, ale także ręcznie podwaja się w celu utworzenia bazowych przypadków rekurencji.

gjest głównym pomrukiem. Rekurencyjnie generuje ostatnie, jedno rozwiązanie, obraca je o 180 stopni, a następnie dodaje kolejne dwa kwadraty.

— Neil
źródło

Spirala Fibonacciego