Perl 6, 10 caracteres:

Lista de secuencia de fibonacci infinita anónima:

^2,*+*...* 

Igual que:

0, 1, -> $x, $y { $x + $y } ... Inf; 

Por lo tanto, puede asignarlo a una matriz:

my @short-fibs = ^2, * + * ... *; 

o

my @fibs = 0, 1, -> $x, $y { $x + $y } ... Inf; 

Y obtenga los primeros once valores (de 0 a 10) con:

say @short-fibs[^11]; 

o con:

say @fibs[^11]; 

Espera, también puedes obtener los primeros 50 números de la propia lista anónima:

say (^2,*+*...*)[^50] 

Eso devuelve:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986 102334155 165580141 267914296 433494437 701408733 1134903170 1836311903 2971215073 4807526976 7778742049 

Y un punto de referencia simple:

real 0m0.966s user 0m0.842s sys 0m0.080s 

Con:

$ time perl6 -e "say (^2, *+* ... *)[^50]" 

EOF

Comentarios

• Yo no ' ni siquiera pensaría de ^2 como reemplazo de 0,1. +1
• Esto ya no es válido, tendrá que escribirlo como |^2,*+*...*, que es el mismo número de bytes que 0,1,*+*...*.
• Perl es tan extraño.
• ¿En qué versión de Perl 6 estaba escrita esta respuesta?
• @CalculatorFeline Hubo un gran cambio conocido como GLR (Great List Refactor) que ocurrió poco antes del primer lanzamiento oficial que fue el 2015-12-25. Este código habría funcionado hasta ese momento.

Brainfuck, 22 golpes

+>++[-<<[->+>+<<]>>>+] 

Genera la secuencia de Fibonacci moviéndose gradualmente a través de la cinta de memoria.

Comentarios

• Hermoso ! ¡Literalmente hermoso! O tal vez no … de todos modos +1 para esto 🙂
• Esto es 3.344 o 4 bytes en una mierda de cerebro comprimida. (6 ln (22)) / ln (256)
• 16 bytes: +[[<+>->+>+<<]>]
• 14 bytes: +[.[>+>+<<-]>]
• @Stefnotch por supuesto, el más corto es destructivo. La solución anterior termina con la secuencia de fibonacci en la cinta, que es lo que también hace la solución de 16 bytes.

Haskell, 17 15 14 caracteres

f=1:scanl(+)1f 

¡Pruébelo en línea!

Comentarios

• ¿Por qué no cortar dos espacios para f=0:scanl(+)1 f?
• @Martinho: Editado, gracias.
• Vaya, eso ' es incluso más corto que el f@(_:x)=0:1:zipWith(+)f x! Tengo que recordarlo.
• Incluso puede quitar otro espacio: f=0:scanl(+)1f.

C # 4, 58 bytes

Secuencia (69; 65 si se escribe débilmente en IEnumerable)

(Suponiendo una directiva using para System.Collections.Generic.)

IEnumerable<int>F(){int c=0,n=1;for(;;){yield return c;n+=c;c=n-c;}} 

Valor único (58)

int F(uint n,int x=0,int y=1){return n<1?x:F(n-1,y,x+y);} 

Comentarios

• Dado que n es un uint, n==0 se puede abreviar a n<1. Y la secuencia puede ahorrar algunos caracteres eliminando el espacio después del tipo genérico y declarando x en un ámbito más amplio de lo necesario.De hecho, deshazte de x por completo: n+=c;c=n-c;
• @Peter: Gracias, editaré cuando tenga tiempo.
• Su versión de valor único es siempre que mi expresión lambda recursiva responda … ¡bien!
• @ wizzwizz4 si ' no equivocado, si !n funciona, entonces también debería n si cambia el condicional.
• @JonSkeet Aw. Y aquí estaba pensando que ' le había ganado a Jon Skeet en C # … 🙂

GolfScript, 12

¡Ahora, solo 12 caracteres!

1.{[email protected]+.}do 

Comentarios

• +1 buen trabajo. Si lo hace más corto que 13 caracteres, ' aceptaré instantáneamente su respuesta (a menos que alguien dé una respuesta aún más corta, por supuesto). 😛
• Me encantan los desafíos. ¡Hecho! 😉
• Bien, tú ganas. Al menos, hasta que alguien haga algo aún más corto (si eso ' es incluso posible). 😛
• esa definición es casi tan corta como el nombre ' Fibonacci '. +1

J, 10 caracteres

Utilizando el cálculo integrado de Coeficientes de la serie de Taylor por lo que quizás un poco engañosos. Lo aprendí aquí .

 (%-.-*:)t. (%-.-*:)t. 0 1 2 3 4 5 10 100 0 1 1 2 3 5 55 354224848179261915075 

Comentarios

• @aditsu (q:^-^:p) 6 es 64 729 donde p es par. J probablemente sea bueno para lo que hace acertijos. 🙂
• Aún mejor: (<:^-^:>) 4 es 81 y <:^-^:> 4 es 53.5982.
• El emoji que se muestra aquí es hacia lo que todo código J debería esforzarse. En una nota al margen, otra alternativa es +/@:!&i.- usando 9 bytes.
• @miles ¡Muy bien! Deberías publicarlo porque es completamente diferente al mío.

> < > – 15 caracteres

0:nao1v a+@:n:<o 

Comentarios

• Aunque puedes acortarlo a 0:nao1v LF a+@:n:<o si quieres. Da 15 🙂 De hecho, esto también hace que la salida sea un poco más legible …
• 13 caracteres: 01r:nao$:@+$r

Hexagony , 18 14 12

¡Gracias Martin por 6 bytes!

1="/}.!+/M8; 

Ampliado:

 1 = " / } . ! + / M 8 ; . . . . . . . 

Pruébelo en línea

Antiguo, respuesta. Esto se ha dejado porque las imágenes y la explicación pueden ser útiles para los nuevos usuarios de Hexagony.

!).={!/"*10;$.[+{] 

Ampliado:

 ! ) . = { ! / " * 1 0 ; $ . [ + { ] . 

Esto imprime la secuencia de Fibonacci separada por líneas nuevas.

¡Pruébelo en línea! Sin embargo, tenga cuidado, el en línea al intérprete realmente no le gusta la salida infinita.

Explicación

Hay dos «subrutinas» en este programa, cada una es ejecutada por una de las dos IP utilizadas. La primera rutina imprime nuevas líneas , y el segundo hace el cálculo de Fibonacci y la salida.

La primera subrutina comienza en la primera línea y se mueve de izquierda a derecha todo el tiempo. Primero imprime el valor en el puntero de memoria (inicializado a cero), y luego incrementa el valor en el puntero de memoria en 1. Después de la no operación, la IP salta a la tercera línea que primero cambia a otra celda de memoria, luego imprime una nueva línea. Dado que una nueva línea tiene un valor positivo (su valor es 10), th El código siempre saltará a la quinta línea siguiente. La quinta línea devuelve el puntero de memoria a nuestro número de Fibonacci y luego cambia a la otra subrutina. Cuando regresemos de esta subrutina, la IP volverá a la tercera línea, después de ejecutar un no-op.

La segunda subrutina comienza en la esquina superior derecha y comienza a moverse hacia el sureste. Después de una operación no operativa, nos obligan a viajar hacia el oeste por la segunda línea. Esta línea imprime el número de Fibonacci actual, antes de mover el puntero de memoria a la siguiente ubicación. Luego, la IP salta a la cuarta línea, donde calcula el siguiente número de Fibonacci utilizando los dos anteriores. Luego devuelve el control a la primera subrutina, pero cuando recupera el control del programa, continúa hasta que encuentra un salto, donde rebota sobre el espejo que se usó originalmente para apuntar al Oeste, ya que regresa a la segunda línea.

¡Imágenes bonitas preliminares!

El lado izquierdo de la imagen es el programa, el lado derecho representa la memoria. El cuadro azul es la primera IP, y ambas IP apuntan a la siguiente instrucción que se ejecutará.

Nota: Las imágenes pueden solo les parecerá bonito a las personas que tienen una habilidad igualmente limitada con los programas de edición de imágenes: PI agregará al menos 2 iteraciones más para que el uso del operador * sea más claro.

Nota 2: Solo vi la respuesta de alephalpha después de escribir la mayor parte de esto, pensé que aún era valioso debido a la separación, pero el Fibonacci real partes de nuestros programas son muy similares. Además, este es el programa Hexagony más pequeño que he visto haciendo uso de más de una IP, así que pensé que sería bueno conservarlo de todos modos: P

Comentarios

• Debes vincular a lo que hayas usado para hacer las bonitas imágenes, luego poner el vínculo en esolangs.org/wiki/ Hexagony .
• @ mbomb007 Usé gimp para crear manualmente cada fotograma, luego cargué las imágenes en algún gi haciendo sitio web. Aunque, varias veces durante este proceso consideré hacer una herramienta para hacerlo, considerando lo tedioso que era.
• @FryAmTheEggman ¡Impresionante! Conviértalo en un desafío. Estoy ' seguro de que alguien publicará una respuesta. : D Aún mejor si pudiera crear un sitio web similar al intérprete en línea de fish '.
• @ mbomb007 Eso podría ser un poco ambicioso para un desafío en este sitio , sin mencionar que probablemente sufriría mucho por ser realmente amplio. No ' creo que publique eso, pero siéntase libre de hacerlo usted mismo si cree que tiene una buena forma de presentarlo. Además, creo que Timwi creó un ide de C # para hexagony, aunque ' nunca lo he usado porque no ' t molestado con mono.
• @ mbomb007 El ide vive aquí , por cierto, olvidé vincularlo la última vez.

VACA , 108

 MoO moO MoO mOo MOO OOM MMM moO moO MMM mOo mOo moO MMM mOo MMM moO moO MOO MOo mOo MoO moO moo mOo mOo moo 

Python 2, 34 bytes

Python, usando recursividad … aquí viene un StackOverflow!

def f(i,j):print i;f(j,i+j) f(1,1) 

Jelly , 3 bytes

+¡1 

¡Pruébelo en línea!

Cómo funciona

+¡1 Niladic link. No implicit input. Since the link doesn"t start with a nilad, the argument 0 is used. 1 Yield 1. + Add the left and right argument. ¡ For reasons‡, read a number n from STDIN. Repeatedly call the dyadic link +, updating the right argument with the value of the left one, and the left one with the return value. 

^‡ ¡ mira los dos enlaces de la izquierda. Como solo hay uno, tiene que ser el cuerpo del bucle. Por lo tanto, se lee un número de la entrada. Como no hay argumentos en la línea de comandos, ese número se lee desde STDIN.

Hexagony , 6 bytes

No competitivo porque el idioma es más nuevo que la pregunta.

1.}=+! 

Ungolfed:

 1 . } = + ! . 

Imprime la secuencia de Fibonacci sin ningún separador.

Comentarios

• Esto tiene el problema menor de que no ' t imprime ningún separador entre los números. Sin embargo, esto no está ' t completamente bien especificado en el desafío. (Y yo ' estoy muy feliz de que alguien esté usando Hexagony. :))

Golfscript – número único – 12/11/10

12 caracteres para tomar datos de stdin:

~0 1@{.@+}*; 

11 caracteres para la entrada que ya están en la pila:

0 1@{.@+}*; 

10 caracteres para definir más 1 como el número 0 de Fibonacci:

1.@{.@+}*; 

Comentarios

• La opción es " Calcula, dado n, el n-ésimo número de Fibonacci ". Así que abandona el ~ y tienes 11 caracteres que toman n en la pila y dejan F_n en la pila.

Ruby

29 27 25 24 caracteres

p a=b=1;loop{b=a+a=p(b)} 

Editar: lo convirtió en un bucle infinito. 😉

Comentarios

• ¿Alguien notó que b=a+a=b es un palíndromo? 🙂
• sí, st0le hizo 🙂
• Sé que ' llego tarde a la fiesta, pero ¿alguien puede explicar cómo b=a+a=b ¿funciona la pieza? ¿No puedo ' no entenderlo.
• @GigaWatt, piénselo de esta manera, las instrucciones se ejecutan de izquierda a derecha …entonces newb=olda+(a=oldb)
• puede guardar 2 caracteres usando loop: p 1,a=b=1;loop{p b=a+a=b}

DC (20 bytes)

Como beneficio adicional, «s incluso ofuscado;)

zzr[dsb+lbrplax]dsax 

EDITAR: Puedo señalar que imprime todos los números en la secuencia de fibonacci, si espera lo suficiente.

Comentarios

• Yo no ' no lo llamaría ofuscado – código ofuscado se supone que es difícil de entender, y en lo que respecta a CC, el código aquí es completamente sencillo.

Mathematica, 9 caracteres

Fibonacci 

Si no se permiten funciones integradas, aquí hay una solución explícita:

Mathematica, 33 32 31 caracteres

#&@@Nest[{+##,#}&@@#&,{0,1},#]& 

Comentarios

• #&@@Nest[{#+#2,#}&@@#&,{0,1},#]& 32 caracteres.
• @chyanog 31: #&@@Nest[{+##,#}&@@#&,{0,1},#]&
• @ Mr.Wizard 24 caracteres (26 bytes): Round[GoldenRatio^#/√5]&
• o 23 caracteres (27 bytes): Round[((1+√5)/2)^#/√5]&

Prelude , 12 bytes

Uno de los pocos desafíos en los que Prelude es bastante competitivo:

1(v!v) ^+^ 

Esto requiere el intérprete de Python que imprime los valores como números decimales en lugar de caracteres.

Explicación

En Prelude, todas las líneas se ejecutan en paralelo, con el puntero de instrucción atravesando las columnas del programa. Cada línea tiene su propia pila que se inicializa a cero.

1(v!v) ^+^ | Push a 1 onto the first stack. | Start a loop from here to the closing ). | Copy the top value from the first stack to the second and vice-versa. | Print the value on the first stack, add the top two numbers on the second stack. | Copy the top value from the first stack to the second and vice-versa. 

El bucle se repite para siempre, porque la primera pila nunca tendrá un 0 encima.

Tenga en cuenta que esto inicia la secuencia de Fibonacci desde 0.

TI-BASIC, 11

Por el legendario golfista de TI-BASIC Kenneth Hammond («Weregoose»), de este sitio . Se ejecuta en tiempo O (1) y considera que 0 es el término 0 de la secuencia de Fibonacci.

int(round(√(.8)cosh(Anssinh‾¹(.5 

Para usar:

2:int(round(√(.8)cosh(Anssinh‾¹(.5 1 12:int(round(√(.8)cosh(Anssinh‾¹(.5 144 

¿Cómo funciona? Si haces los cálculos, resulta que sinh‾¹(.5) es igual a ln φ, por lo que es una versión modificada de la fórmula de Binet que redondea hacia abajo en lugar de utilizar el término de corrección (1/φ)^n. El round( (redondeado a 9 posiciones decimales) es necesario para evitar errores de redondeo.

K – 12

Calcula el n y n-1 número de Fibonacci.

{x(|+\)/0 1} 

Solo el nth número de Fibonacci.

{*x(|+\)/0 1} 

Comentarios

• +1 ¡Nada mal! Si pudiera reducirlo solo un carácter (y proporcionarme una manera de probarlo), ' aceptaré su respuesta. 🙂
• La única forma de reducirlo sería reemplazar la función con una llamada a un número conocido: n (| + \ ) / 0 1 Pruébelo usando este intérprete .

Java, 55

No puedo competir con la concisión de la mayoría de los lenguajes aquí, pero puedo ofrecer una forma sustancialmente diferente y posiblemente mucho más rápida (tiempo constante) de calcular el n-ésimo número:

Math.floor(Math.pow((Math.sqrt(5)+1)/2,n)/Math.sqrt(5)) 

n es la entrada (int o long), comenzando con n = 1. Utiliza Fórmula de Binet y redondea en lugar de la resta.

Comentarios

• Me encanta esta solución
• Esto no ' parece funcionar para mí, pero ' es temprano y ¡Falta algo! Suponiendo que 0 sea el primer número de la secuencia, esto da 0, 0, 1, 1, 3, 4, 8, 12, 21, 33 para los primeros t 10 números
• @Shaggy ¡Ups! Lo siento, presenté un error, solucionado ahora.

Julia, 18 bytes

n->([1 1;1 0]^n)[] 

Dodos , 26 bytes

	dot F F 	F dip 	F dip dip 

Pruébelo en línea

Cómo funciona

La función F hace todo el trabajo pesado; se define de forma recursiva como sigue.

F(n) = ( F(|n - 1|), F(||n - 1| - 1|) ) 

Siempre que n> 1 , tenemos | n – 1 | = n – 1 < n y || n – 1 | – 1 | = | n – 1 – 1 | = n – 2 < n , por lo que la función devuelve (F (n – 1), F (n – 2)) .

If n = 0 , luego | n – 1 | = 1> 0 ; si n = 1 , entonces || n – 1 | – 1 | = | 0 – 1 | = 1 = 1 . En ambos casos, las llamadas recursivas intentadas F (1) generan una excepción Surrender , por lo que F (0) devuelve 0 y F (1) devuelve 1 .

Por ejemplo, F (3) = (F (1), F (2)) = (1 , F (0), F (1)) = (1, 0, 1) .

Por último, el main función se define como

main(n) = sum(F(n)) 

por lo que suma todas las coordenadas del vector devuelto por F .

Por ejemplo, main (3) = sum (F (3)) = sum (1, 0, 1) = 2 .

Comentarios

• Leí su README (DODOS) y estoy súper intrigado; ¡Es un concepto realmente genial! Pero no puedo encontrarlo en Esolangs ni en ningún otro lugar. ¿Se te ocurrió?

Ruby, 25 caracteres

st0le «s respuesta abreviada.

p 1,a=b=1;loop{p b=a+a=b} 

Comentarios

• En realidad, puede acortarlo aún más con a=b=1;loop{p a;b=a+a=b}
• Entonces, ¿escribiste su respuesta?: P

R, 40 bytes

No he visto un Solución R, entonces:

f=function(n)ifelse(n<3,1,f(n-1)+f(n-2)) 

Comentarios

• Sé que esta es una respuesta antigua, pero puede acortarse a 38 bytes

05AB1E, 7 bytes

Código:

1$<FDr+ 

¡Pruébelo en línea!

Comentarios

• Hola y bienvenido a PPCG. ¡Buen primer mensaje!

GolfScript, 13 caracteres

2,~{..p@+.}do 

(Mi respuesta de un pregunta anterior de Stack Overflow .)

Desmos , 61 bytes

Golf

Haga clic en add slider botón para n.

p=.5+.5\sqrt{5} n=0 f=5^{-.5}\left(p^n-\left(-p\right)^{-n}\right) 

La última línea es la salida.

Ungolfed

Es una función.

\phi =\frac{1+\sqrt{5}}{2} f_{ibonacci}\left(n\right)=\frac{\phi ^n-\left(-\phi \right)^{-n}}{\sqrt{5}} 

Cubix , 10 bytes

Respuesta no competitiva porque el lenguaje es más nuevo que la pregunta.

Cubix es un nuevo lenguaje bidimensional de @ETHproductions donde el código está envuelto en un cubo del tamaño adecuado.

;.o.ON/+!) 

Pruébelo en línea

Esto encaja en un 2 x 2 cubo de la siguiente manera

 ; . o . O N / + ! ) . . . . . . . . . . . . . . 

• O generar el valor del TOS
• N insertar nueva línea en la pila
• / reflejar el norte
• o muestra el carácter del TOS
• ; pop TOS
• / reflejar el este después de dar la vuelta al cubo
• + agregar los 2 valores superiores de la pila
• ! omitir el siguiente comando si TOS es 0
• ) incrementar el TOS en 1. Esto inicia la secuencia esencialmente.

Este es un bucle sin fin que imprime la secuencia con un separador de nueva línea. Aprovecha el hecho de que la mayoría de los comandos no extraen los valores de la pila.
Si se ignora el separador, esto se puede hacer con 5 bytes .O+!)

Brainfuck, 16,15, 14/13 caracteres

+[[->+>+<<]>] 

Genera la secuencia de Fibonacci y no imprime nada. Además, es más corto que el anterior.

+[.[->+>+<<]>] 

Este uno tiene 14 caracteres pero imprime caracteres ASCII con los valores de la secuencia de Fibonacci.

Comentarios

• Esto es bueno, pero sería incorrecto al decir que la versión de 14 bytes solo sale del segundo 1 en adelante? Como en " 1 2 3 5 8 " en lugar de " 1 1 2 3 5 8 "?
• @Charlim Oh, tú ' tienes razón. No tengo idea de lo que pensaba el yo de 2014. De todos modos, lo arreglé moviendo colocando la instrucción de impresión al frente del bucle.