Perl 6, 10 caracteres:

Lista de sequência de fibonacci infinita anônima:

^2,*+*...* 

O mesmo que:

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

Portanto, você pode atribuí-lo a uma matriz:

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

ou

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

E obtenha os primeiros onze valores (de 0 a 10) com:

say @short-fibs[^11]; 

ou com:

say @fibs[^11]; 

Espere, você também pode obter os primeiros 50 números da própria lista anônima:

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

Isso retorna:

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 

E alguns benchmarks simples:

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

Com:

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

EOF

Comentários

• Eu não ' nem pensaria de ^2 como substituto de 0,1. +1
• Isso não é mais válido, você terá que escrever como |^2,*+*...*, que é o mesmo número de bytes que 0,1,*+*...*.
• Perl é tão estranho.
• Em que versão do Perl 6 essa resposta foi escrita?
• @CalculatorFeline Houve uma grande mudança conhecido como GLR (Great List Refactor), que aconteceu pouco antes do primeiro lançamento oficial que foi em 2015-12-25. Esse código teria funcionado até então.

Brainfuck, 22 tacadas

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

Gera a sequência Fibonacci movendo-se gradualmente pela fita de memória.

Comentários

• Linda ! Literalmente lindo! Ou talvez não … de qualquer forma, +1 para isso 🙂
• Isso é 3.344 ou 4 bytes em brainfuck compactado. (6 ln (22)) / ln (256)
• 16 bytes: +[[<+>->+>+<<]>]
• 14 bytes: +[.[>+>+<<-]>]
• @Stefnotch é claro, o mais curto é destrutivo. A solução acima termina com a sequência de fibonacci na fita, que é o que a solução de 16 bytes também faz.

Haskell, 17 15 14 caracteres

f=1:scanl(+)1f 

Experimente online!

Comentários

• Por que não cortar dois espaços f=0:scanl(+)1 f?
• @Martinho: Editado, obrigado.
• Uau, esse ' é ainda mais curto que o f@(_:x)=0:1:zipWith(+)f x! Tem que se lembrar disso.
• Você pode até retirar outro espaço: f=0:scanl(+)1f.

C # 4, 58 bytes

Stream (69; 65 se mal digitado para IEnumerable)

(Supondo uma diretiva 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);} 

Comentários

• Dado que n é um uint, n==0 pode ser reduzido para n<1. E o stream pode economizar alguns caracteres eliminando o espaço após o tipo genérico e declarando x em um escopo mais amplo do que o necessário.Na verdade, descarte x inteiramente: n+=c;c=n-c;
• @Peter: Obrigado, editarei quando eu tiver algum tempo.
• Sua versão de valor único é tão longa quanto minha expressão lambda recursiva responder … bom!
• @ wizzwizz4 se eu ' m não engano, se !n funcionar, então deve apenas n se você inverter a condicional.
• @JonSkeet Aw. E aqui estava eu pensando que ' d bati Jon Skeet em C # … 🙂

GolfScript, 12

Agora, apenas 12 caracteres!

1.{[email protected]+.}do 

Comentários

• +1 bom trabalho. Se você torná-lo menor que 13 caracteres, eu ' aceitarei sua resposta instantaneamente (a menos que alguém faça uma resposta ainda mais curta, é claro). 😛
• Eu adoro desafios. Feito! 😉
• Legal, você ganhou. Pelo menos até que alguém faça algo ainda mais curto (se ' for possível). 😛
• essa definição é quase tão curta quanto o próprio nome ' Fibonacci '! +1

J, 10 caracteres

Usando o cálculo integrado de Coeficientes da série de Taylor talvez sejam baratos. Aprendi aqui .

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

Comentários

• @aditsu (q:^-^:p) 6 é 64 729 onde p é par. J é provavelmente bom para o que faz enigmas. 🙂
• Ainda melhor: (<:^-^:>) 4 é 81 e <:^-^:> 4 é 53.5982.
• O emoji demonstrado aqui é o objetivo de todo o código J. Em uma observação lateral, outra alternativa é +/@:!&i.- usando 9 bytes.
• @miles Muito bom! Você deve publicá-lo, pois é totalmente diferente do meu.

> < > – 15 caracteres

0:nao1v a+@:n:<o 

Comentários

• Embora você possa encurtá-lo para 0:nao1v LF a+@:n:<o se você quiser. Fornece 15 🙂 Na verdade, isso também torna a saída um pouco mais legível …
• 13 caracteres: 01r:nao$:@+$r

Hexagonia , 18 14 12

Obrigado Martin por 6 bytes!

1="/}.!+/M8; 

Expandido:

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

Experimente online

Antigo, responda. Isso está sendo deixado porque as imagens e a explicação podem ser úteis para novos usuários do Hexagony.

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

Expandido:

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

Isso imprime a sequência de Fibonacci separada por novas linhas.

Experimente online! Porém, tenha cuidado, o online intérprete realmente não gosta de saída infinita.

Explicação

Existem duas “sub-rotinas” para este programa, cada uma é executada por um dos dois IPs utilizados. A primeira rotina imprime novas linhas , e o segundo faz o cálculo de Fibonacci e a saída.

A primeira sub-rotina começa na primeira linha e se move da esquerda para a direita o tempo todo. Ela primeiro imprime o valor no ponteiro de memória (inicializado em zero), e então incrementa o valor no ponteiro de memória em 1. Após o no-op, o IP salta para a terceira linha que primeiro muda para outra célula de memória e, em seguida, imprime uma nova linha. uma nova linha tem um valor positivo (seu valor é 10), o O código sempre pulará para a quinta linha, a seguir. A quinta linha retorna o ponteiro de memória para nosso número de Fibonacci e então muda para a outra sub-rotina. Quando voltarmos desta sub-rotina, o IP irá pular de volta para a terceira linha, após executar um no-op.

A segunda sub-rotina começa no canto superior direito e começa a se mover para sudeste. Depois de um no-op, somos obrigados a viajar para o oeste ao longo da segunda linha. Esta linha imprime o número de Fibonacci atual, antes de mover o ponteiro da memória para o próximo local. Em seguida, o IP salta para a quarta linha, onde calcula o próximo número de Fibonacci usando os dois anteriores. Em seguida, ele devolve o controle à primeira sub-rotina, mas quando recupera o controle do programa, continua até encontrar um salto, onde salta sobre o espelho que foi originalmente usado para apontá-lo para o oeste, conforme retorna para a segunda linha.

Imagens bonitas preliminares!

O lado esquerdo da imagem é o programa, o lado direito representa a memória. A caixa azul é o primeiro IP e ambos os IPs apontam para a próxima instrução a ser executada.

Observação: as imagens podem só parece bonito para pessoas que têm habilidades igualmente limitadas com programas de edição de imagens: o PI adicionará pelo menos mais 2 iterações para que o uso do operador * fique mais claro.

Observação 2: eu só vi a resposta da alephalpha “ depois de escrever a maior parte disso. Achei que ainda era valioso por causa da separação, mas o Fibonacci real partes de nossos programas são muito semelhantes. Além disso, este é o menor programa Hexagony que eu vi fazendo uso de mais de um IP, então pensei que seria bom mantê-lo de qualquer maneira: P

Comentários

• Você deve criar um link para o que quer que tenha usado para fazer as belas imagens e, em seguida, colocar o link em esolangs.org/wiki/ Hexagonia .
• @ mbomb007 Usei o gimp para criar manualmente cada quadro, depois carreguei as imagens em algum gi f fazer site. Embora, várias vezes durante esse processo, pensei em fazer uma ferramenta para fazer isso, considerando o quão tedioso era.
• @FryAmTheEggman Impressionante! Faça disso um desafio. Eu ' tenho certeza de que alguém postará uma resposta. : D Ainda melhor se você pudesse criar um site semelhante ao intérprete online fish ' s.
• @ mbomb007 Isso pode ser um pouco ambicioso para um desafio neste site , sem falar que provavelmente sofreria muito por ser realmente amplo. Não ' acho que não postarei isso, mas sinta-se à vontade para fazer você mesmo se achar que tem uma boa maneira de apresentá-lo. Além disso, acredito que Timwi criou um ide C # para hexagonia, embora eu ' nunca o tenha usado porque não ' me incomodei com mono.
• @ mbomb007 O ide vive aqui , a propósito, esqueci de vinculá-lo da última vez.

COW , 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 recursão … aqui vem um StackOverflow!

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

Jelly , 3 bytes

+¡1 

Experimente online!

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

^‡ ¡ dá uma olhada nos dois links à esquerda. Como há apenas um, ele deve ser o corpo do loop. Portanto, um número é lido da entrada. Como não há argumentos de linha de comando, esse número é lido em STDIN.

Hexagonia , 6 bytes

Não concorrente porque a linguagem é mais recente do que a pergunta.

1.}=+! 

Ungolfed:

 1 . } = + ! . 

Imprime a sequência de Fibonacci sem nenhum separador.

Comentários

• Isso tem o menor problema de não ' imprimir qualquer separador entre os números. No entanto, isto não está ' totalmente bem especificado no desafio. (E eu ' estou muito feliz que alguém esteja usando Hexagony. :))

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

12 caracteres para receber a entrada de stdin:

~0 1@{.@+}*; 

11 caracteres para entrada já na pilha:

0 1@{.@+}*; 

10 caracteres para definir posteriormente 1 como o 0º número de Fibonacci:

1.@{.@+}*; 

Comentários

• A opção é " Calcula, dado n, o enésimo número de Fibonacci ". Então descarte o ~ e você terá 11 caracteres que ocupam n na pilha e deixam F_n na pilha.

Ruby

29 27 25 24 caracteres

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

Editar: tornava um loop infinito. 😉

Comentários

• alguém percebeu que b=a+a=b é um palíndromo? 🙂
• sim, st0le fez 🙂
• Eu sei que ' estou atrasado para a festa, mas alguém pode explicar como o b=a+a=b parte funciona? Não consigo ' não consigo entender isso.
• @GigaWatt, Pense desta forma, as instruções são executadas da esquerda para a direita …então newb=olda+(a=oldb)
• você pode salvar 2 caracteres usando loop: p 1,a=b=1;loop{p b=a+a=b}

DC (20 bytes)

Como um bônus, “está até ofuscado;)

zzr[dsb+lbrplax]dsax 

EDITAR: Posso salientar que ele imprime todos os números na sequência de fibonacci, se você espera o suficiente.

Comentários

• Eu não ' não chamaria de ofuscado – código ofuscado é suposto ser difícil de entender e, no que diz respeito a DC, o código aqui é completamente direto.

Mathematica, 9 caracteres

Fibonacci 

Se funções embutidas não são permitidas, aqui está uma solução explícita:

Mathematica, 33 32 31 caracteres

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

Comentários

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

Prelúdio , 12 bytes

Um dos poucos desafios em que o Prelúdio é realmente bastante competitivo:

1(v!v) ^+^ 

Isso requer o interpretador Python que imprime valores como números decimais em vez de caracteres.

Explicação

No Prelúdio, todas as linhas são executadas em paralelo, com o ponteiro da instrução percorrendo as colunas do programa. Cada linha tem sua própria pilha inicializada com zero.

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. 

O loop se repete para sempre, porque a primeira pilha nunca terá um 0 no topo.

Observe que isso inicia a sequência de Fibonacci de 0.

TI-BASIC, 11

Do lendário jogador de golfe TI-BASIC Kenneth Hammond (“Weregoose”), deste site . É executado em tempo O (1) e considera 0 como o 0º termo da sequência 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 

Como isso funciona? Se você fizer as contas, verifica-se que sinh‾¹(.5) é igual a ln φ, então é “uma versão modificada da fórmula de Binet” que arredonda para baixo em vez de usar o (1/φ)^n termo de correção. O round( (arredondado para 9 casas decimais) é necessário para evitar erros de arredondamento.

K – 12

Calcula o n e n-1 número de Fibonacci.

{x(|+\)/0 1} 

Apenas o nth número Fibonacci.

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

Comentários

• +1 Nada mal! Se você pudesse reduzir apenas um caractere (e me fornecer uma maneira de testá-lo), ' aceitarei sua resposta. 🙂
• A única maneira de reduzi-lo seria substituir a função por uma chamada para um número conhecido: n (| + \ ) / 0 1 Teste-o usando este intérprete .

Java, 55

Não posso competir com a concisão da maioria das linguagens aqui, mas posso oferecer uma maneira substancialmente diferente e possivelmente muito mais rápida (tempo constante) de calcular o enésimo número:

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

n é a entrada (int ou longo), começando com n = 1. Ele usa Fórmula de Binet e arredondamentos em vez da subtração.

Comentários

• Eu adoro esta solução
• Isso não ' não parece funcionar para mim, mas ' é cedo e posso estar faltando alguma coisa! Assumindo que 0 seja o primeiro número na sequência, isso dá 0, 0, 1, 1, 3, 4, 8, 12, 21, 33 para os primeiros t 10 números
• @Shaggy Oops! Desculpe, introduzi um bug – corrigido agora.

Julia, 18 bytes

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

Dodos , 26 bytes

	dot F F 	F dip 	F dip dip 

Experimente online!

Como funciona

A função F faz todo o trabalho pesado; ele é definido recursivamente da seguinte maneira.

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

Sempre que n> 1 , temos | n – 1 | = n – 1 < n e || n – 1 | – 1 | = | n – 1 – 1 | = n – 2 < n , então a função retorna (F (n – 1), F (n – 2)) .

Se n = 0 , então | n – 1 | = 1> 0 ; if n = 1 , então || n – 1 | – 1 | = | 0 – 1 | = 1 = 1 . Em ambos os casos, as tentativas de chamadas recursivas F (1) geram uma exceção Surrender , então F (0) retorna 0 e F (1) retorna 1 .

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

Finalmente, o main a função é definida como

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

portanto, adiciona todas as coordenadas do vetor retornado por F .

Por exemplo, principal (3) = sum (F (3)) = sum (1, 0, 1) = 2 .

Comentários

• Li seu README (DODOS) e estou super intrigado; é um conceito muito legal! Mas não consigo encontrar em Esolangs ou em qualquer outro lugar. Você pensou nisso?

Ruby, 25 caracteres

st0le “resposta abreviada.

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

Comentários

• Na verdade, você pode encurtá-la ainda mais usando a=b=1;loop{p a;b=a+a=b}
• Então você escreveu a resposta dele?: P

FAC: APL funcional, 4 caracteres (!!)

Não é meu, portanto postado como wiki da comunidade. FAC é um dialeto do APL que Hai-Chen Tu aparentemente sugeriu como sua dissertação de doutorado em 1985. Ele escreveu posteriormente um artigo junto com Alan J. Perlis chamado “ FAC: A Functional APL Language “. Este dialeto do APL usa “matrizes preguiçosas” e permitem matrizes de comprimento infinito. Define um operador “iter” (⌼) para permitir a definição compacta de algumas sequências recursivas.

O monádico (“unário “) caso de ⌼ é basicamente Haskell” s , e é definido como (F⌼) A ≡ A, (F A), (F (F A)), …. O caso diádico (“binário”) é definido de forma análoga para duas variáveis: A (F⌼) B ≡ A, B, (A F B), (B F (A F B)), …. Por que isso é útil? Bem, acontece que este é precisamente o tipo de recorrência que a sequência de Fibonacci tem. Na verdade, um dos exemplos dados disso é

1+⌼1 

produzindo a sequência familiar 1 1 2 3 5 8 ….

Então, aí está, provavelmente a implementação Fibonacci mais curta possível em uma linguagem de programação não inovadora. : D

Comentários

• Oh, eu acidentalmente cancelei o wiki da comunidade de sua postagem como parte da minha (manual) anulação em massa. Ah bem. 😉

R, 40 bytes

Não vi um Solução R, então:

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

Comentários

• Eu sei que esta é uma resposta antiga, mas você pode reduzir para 38 bytes

05AB1E, 7 bytes

Código:

1$<FDr+ 

Experimente online!

Comentários

• Olá, e bem-vindo ao PPCG! Bom primeiro post!

GolfScript, 13 caracteres

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

(Minha resposta de um pergunta anterior do Stack Overflow .)

Desmos , 61 bytes

Jogado golfe

Clique em add slider botão para n.

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

A última linha é a saída.

Ungolfed

É uma função.

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

Cubix , 10 bytes

Resposta não competitiva porque a linguagem é mais recente que a pergunta.

Cubix é uma nova linguagem bidimensional da @ETHproductions onde o código é empacotado em um cubo dimensionado para caber.

;.o.ON/+!) 

Experimente on-line

Isso termina em um 2 cubo x 2 da seguinte maneira

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

• O produzindo o valor do TOS
• N colocar nova linha na pilha
• / refletir o norte
• o produza o caractere do TOS
• ; TOS pop
• / reflita para o leste depois de contornar o cubo
• + adicione os 2 principais valores da pilha
• ! pule o próximo comando se o TOS for 0
• ) incremente o TOS em 1. Isso inicia a sequência essencialmente.

Este é um loop infinito que imprime a sequência com um separador de nova linha. Ele tira vantagem do fato de que a maioria dos comandos não retira os valores da pilha.
Se o separador for ignorado, isso pode ser feito com 5 bytes .O+!)

Brainfuck, 16,15, 14/13 caracteres

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

Gera a sequência de Fibonacci e não imprime nada. Além disso, é mais curto do que o acima.

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

Este um tem 14 caracteres, mas imprime caracteres ASCII com os valores da sequência de Fibonacci.

Comentários

• Isso é bom, mas estaria incorreto em dizer que a versão de 14 bytes só sai do segundo 1 em diante? Como em " 1 2 3 5 8 " em vez de " 1 1 2 3 5 8 "?
• @Charlim Oh, você ' está certo. Não tenho ideia do que o eu de 2014 pensava. De qualquer forma, acabei de consertar com mov levando a instrução de impressão para a frente do loop.