Su objetivo es generar una espiral de Fibonacci con números.

Muestra

Ejemplo de entrada / salida

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

Entrada de 9

Entrada La entrada se puede tomar a través de STDIN o argumento de función. Será un solo número

Salida La salida puede ser de STDOUT o el valor de retorno de una función. Debería ser una sola cadena.

No se permiten espacios en blanco adicionales al final de la línea. La salida puede contener dígitos, avances de línea (nuevas líneas) y espacios.

La orientación no importa, esto significa rotaciones y reflexiones. Siempre que siga un patrón espiral de Fibonacci válido.

Los números con diferentes cantidades de dígitos (por ejemplo, 1 y 13) deben estar alineados a la derecha entre sí. Es posible que sea necesario agregar un espacio al comienzo de una línea para que todo pueda alinearse.

1   1                          1   1
100 100  should actually be  100 100

Puedes ver un ejemplo aquí

Este es el código de golf, ¡el código más corto en bytes gana!

code-golf fibonacci Downgoat
fuente

44

Desafío relacionado (y un reloj genial)

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.

Esto suena como que podría ser más claro como dos oraciones.

trichoplax

En los ejemplos, parece que desea que se alinee el dígito más a la derecha de cada número, pero "alineado al lado izquierdo del dígito" suena como lo opuesto.

trichoplax

¿Puedes aclarar que "el espacio en blanco no está permitido"? En particular, ¿son aceptables los espacios en blanco iniciales o finales en las líneas?

MtnViewMark

Matlab imprime la salida a stdout por defecto. ¿Es aceptable tener una salida de tipo numérico (a diferencia de la salida de tipo cadena) que se imprime automáticamente en stdout?

Luis Mendo

15

APL, 23

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

Explicación:

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

Pruébalo en tryapl.org

Moris Zucca
fuente

1

Si busca aquí, muchos tuvieron su duda antes. Aquí está, por ejemplo, la respuesta de @Tobia: * Dyalog APL admite un juego de caracteres heredado que tiene los símbolos APL asignados a los valores superiores de 128 bytes. Por lo tanto, un programa APL que solo usa caracteres ASCII y símbolos APL puede considerarse bytes == caracteres.

Moris Zucca

Bien entonces, retractaré mi comentario.

gar

1

@MorisZucca Sin embargo, tenga en cuenta que faltan algunos caracteres (como ⌸o ⍤) en ese conjunto de caracteres y no se pueden usar cuando desea evocar esa regla.

FUZxxl

1

Es cierto que "clave" y "rango" son implementaciones más recientes y, de hecho, solo existen en la versión Unicode del intérprete Dyalog que uso. La versión clásica tiene que usar el ⎕command equivalente. Lo mismo se aplica a ⍠ (⎕OPT) también, por ejemplo. Por lo tanto, generalmente pienso que si puedo escribirlo en la versión Dyalog Classic, es seguro decir que es 1 byte por char. Corrígeme si me equivoco. Y gracias por el comentario.

Moris Zucca

8

Matlab, 84 bytes

Se usa una función. La salida 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)

Ejemplos:

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

Igual que el anterior, excepto que se explota la característica de Matlab, es decir, muestra automáticamente la salida de la función (como una cadena) en stdout. Esto evita la conversión a cadena en el enfoque anterior.

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
fuente

me alegra ver algunas soluciones de Matlab :-)

Hoki

@Hoki ¡Gracias! :-)

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)

Las reglas relajadas sobre las rotaciones hacen que esto sea mucho más simple.

No he usado backticks en lugar de str(a)aquí porque no estoy seguro de si se nos permiten más espacios iniciales de los necesarios, si alguna vez llegamos a largos. Aunque, incluso si lo fuéramos, usarlo asería más corto de todos modos.

Sp3000
fuente

7

Rubí, 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
fuente

1

Buen golf! Puede guardar algunos caracteres en la línea 4, convirtiendo las t==valuecondiciones a t>value. Por ejemplo,(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
fuente

6

J, 36 bytes

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

Uso:

   (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étodo:

La función gira el cuadrado actual y agrega el nuevo cuadrado al actual una input-1vez. El tamaño del cuadrado y los valores de los elementos se recopilan del tamaño del rectángulo anterior.

Explicación del código:

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

Pruébelo en línea aquí.

randomra
fuente

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

La función es f, que toma un número y devuelve una sola cadena:

λ: 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
fuente

5

Pyth, 34 bytes

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

Sorprendentemente, más de la mitad del código está imprimiendo / rellenando, en lugar de generar la matriz.

La generación de la matriz es realmente simple, sin embargo, consiste en una transposición y una inversión, y agrega N líneas que contienen N copias de N, donde N es el número actual de líneas.

Ejemplo de salida para 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
fuente

4

Perl, 289277257 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
fuente

4

K, 48 bytes

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

Y en acción:

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

Todavía puede haber algunas buenas oportunidades para jugar al golf.

El programa consiste básicamente en dos partes: generar la matriz concatenada y formatearla para la salida. El primero es bastante 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)

Comenzando con una matriz 1x1 que contiene 1, construya un vector de longitud T de T donde T es la longitud de la matriz inicial en la primera dimensión ( t#t:#x) y adjúntelo a cada fila de la matriz original ( x,\:). Invertir y transponer el resultado ( +|) lo gira 90 grados. Hacemos esto N-1 veces.

El formato es bastante complicado, porque el enfoque natural de K para imprimir una matriz no alineará las columnas numéricas de la manera que necesitamos:

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

La idea básica es tomar el elemento máximo de la matriz ( |//x), convertirlo en una cadena (unaria $), tomar su longitud más uno ( 1+#) y luego formatear los elementos de la matriz en cadenas alineadas a la derecha de ese tamaño. Luego, para ordenar, unir esas cadenas ( ,/') y soltar el espacio inicial resultante ( 1_').

JohnE
fuente

4

CJam, 48 bytes

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

Pruébalo en línea

La parte central de generar el patrón parece razonablemente sencilla. Gire el rectángulo creado hasta ahora y agregue un cuadrado de valores en la parte inferior.

Sin embargo, el código para rellenar el resultado parece horrible. Intenté varias combinaciones fy :operadores para aplicar el relleno a la lista anidada, pero nada funcionó. Si alguien tiene mejores sugerencias, son bienvenidas.

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
fuente

La inversión de todas las líneas se puede hacer con Wf%. Además, ¿sería capaz de hacer algo {Se[}ff%más que :U;{USe[}f%el relleno? (Eso podría no funcionar como es, no puedo pensarlo ahora.)

Esolanging Fruit

2

Pyth, 29 bytes

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

Demostración.

Si el relleno fuera libre / implícito, como en APL, o se permitiera la salida de matriz, esto sería 14 bytes:

u+C_GmmlGGGQ]Y

isaacg
fuente

2

Rubí, 129 bytes

Edité la otra respuesta de Ruby un montón, pero mi cambio más reciente no está siendo aceptado o algo así, así que aquí está:

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

usuario2251284
fuente

1

Bienvenido a PPCG! Las mejoras de golf generalmente se rechazan por aquí (si sus otras sugerencias fueron aceptadas, eso debe haber sido un descuido), porque se supone que deben publicarse en comentarios para que el autor las revise. Vea esta meta publicación para el razonamiento detrás de esta política.

Martin Ender

Gracias por la información, tiene sentido. Comentar es lo que hubiera hecho originalmente, pero no tenía suficientes puntos de reputación para comentar, pero lo haré en el futuro. ¡Feliz golf!

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

Donde \nrepresenta un carácter de nueva línea literal.

Molesto, el formato ocupa una gran parte del código.

fes una función auxiliar que crea una matriz completa. Se usa principalmente para crear los cuadrados rellenos, pero también se dobla fácilmente para producir los casos base para la recursión.

gEs el principal gruñido. Genera recursivamente la última pero una solución, la gira 180 grados y luego agrega los siguientes dos cuadrados.

Neil
fuente

Espiral de Fibonacci