A sequência de Fibonacci é uma sequência de números, onde cada número na sequência é a soma dos dois números que a precedem. Os dois primeiros números da sequência são 1.

Aqui estão os primeiros termos

1 1 2 3 5 8 13 21 34 55 89 ...

Escreva o código mais curto que:

• Gera a sequência de Fibonacci sem fim.

• Dado ncalcula o ntermo th da sequência. (1 ou zero indexado)

Você pode usar formas padrão de entrada e saída.

(Dei as duas opções, caso uma seja mais fácil de fazer no idioma escolhido do que a outra.)

Para a função que recebe um n, um valor de retorno razoavelmente grande (o maior número de Fibonacci que se encaixa no tamanho normal de palavra do seu computador, no mínimo) deve ser suportado.

Entre os melhores

/* Configuration */

var QUESTION_ID = 85; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 3; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    else console.log(body);
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    lang = jQuery('<a>'+lang+'</a>').text();
    
    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body {
  text-align: left !important;
  display: block !important;
}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">
<div id="language-list">
  <h2>Shortest Solution by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Perl 6, 10 caracteres:

Lista de sequências infinitas de fibonacci anônimas:

^2,*+*...*

Igual a:

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 50 primeiros 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 uma referência simples:

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

Com:

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

EOF

Brainfuck, 22 cursos

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

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

Haskell, 17 15 14 caracteres

f=1:scanl(+)1f

Experimente online!

C # 4, 58 bytes

Stream (69; 65 se digitado de maneira fraca IEnumerable)

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

GolfScript, 12

Agora, apenas 12 caracteres!

1.{[email protected]+.}do

> <> - 15 caracteres

0:nao1v LF a+@:n:<o

J, 10 caracteres

Usando o cálculo interno dos coeficientes da série Taylor, talvez seja um pouco mais barato. Aprendi aqui .

   (%-.-*:)t.

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

Hexagony ,18 14 12

Obrigado Martin por 6 bytes!

1="/}.!+/M8;

Expandido:

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

Experimente online

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

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

Expandido:

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

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

Experimente online! Tenha cuidado, porém, o intérprete on-line realmente não gosta de saída infinita.

Explicação

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

A primeira sub-rotina começa na primeira linha e se move da esquerda para a direita o tempo todo. Primeiro, imprime o valor no ponteiro da memória (inicializado em zero) e depois incrementa o valor no ponteiro da memória 1. Após o no-op, o IP salta para a terceira linha que primeiro muda para outra célula de memória e depois imprime uma nova linha. Como uma nova linha tem um valor positivo (seu valor é 10), o código sempre passará para a quinta linha, a seguir. A quinta linha retorna o ponteiro da memória para o nosso número de Fibonacci e depois muda para a outra sub-rotina. Quando voltarmos desta sub-rotina, o IP voltará para a terceira linha, depois de 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 levados a viajar para o oeste ao longo da segunda linha. Esta linha imprime o número atual de Fibonacci, antes de mover o ponteiro de 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, quando retorna à segunda linha.

Fotos bonitas preliminares!

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

Nota: As imagens podem parecer bonitas apenas para pessoas com habilidades igualmente limitadas nos programas de edição de imagens: o PI adicionará pelo menos mais duas iterações para que o uso do *operador fique mais claro.

Nota 2: Eu só vi a resposta de alefhalpha depois de escrever a maior parte disso, achei que ainda era valiosa por causa da separação, mas as partes reais de Fibonacci de nossos programas são muito semelhantes. Além disso, este é o menor programa Hexagony que eu já vi usando mais de um IP, então achei que seria bom manter assim: P

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)

Gelatina , 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.

^‡ ¡ espreita os dois links à esquerda. Como existe 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.

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

12 caracteres para obter informações do stdin:

~0 1@{.@+}*;

11 caracteres para entrada já na pilha:

0 1@{.@+}*;

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

1.@{.@+}*;

Rubi

29 27 25 24 Chars

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

Edit: transformou em um loop infinito. ;)

Mathematica, 9 caracteres

Fibonacci

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

Mathematica, 33 32 31 caracteres

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

DC (20 bytes)

Como um bônus, é até ofuscado;)

zzr[dsb+lbrplax]dsax

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

Prelúdio , 12 bytes

Um dos poucos desafios em que o Prelude é 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 Prelude, 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, que é inicializada em 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 0no topo.

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

Hexagonia , 6 bytes

Não competir porque o idioma é mais recente que a questão.

1.}=+!

Ungolfed:

  1 .
 } = +
  ! .

Imprime a sequência de Fibonacci sem nenhum separador.

TI-BASIC, 11

Pelo lendário jogador de golfe TI-BASIC Kenneth Hammond ("Weregoose"), deste site . É executado no tempo O (1) e considera 0 como o 0º termo da sequência de Fibonacci.

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

Usar:

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

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

Como é que isso funciona? Se você fizer as contas, 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/φ)^ntermo de correção. A round((arredondar para 9 casas decimais) é necessária para evitar erros de arredondamento.

K - 12

Calcula o número ne n-1Fibonacci.

{x(|+\)/0 1}

Apenas o nthnúmero de Fibonacci.

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

Julia, 18 bytes

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

Java, 55

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

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

né a entrada (int ou longa), iniciando com n = 1. Ele usa a fórmula e os arredondamentos de Binet em vez da subtração.

Ruby, 25 caracteres

a resposta de st0le foi reduzida.

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

FAC: APL funcional, 4 caracteres (!!)

Não é meu, portanto, publicado como wiki da comunidade. FAC é um dialeto da APL que Hai-Chen Tu aparentemente sugeriu como sua dissertação de doutorado em 1985. Mais tarde, ele escreveu um artigo em conjunto com Alan J. Perlis chamado " FAC: uma linguagem funcional da APL ". Esse dialeto do APL usa "matrizes preguiçosas" e permite matrizes de tamanho infinito. Ele define um operador "iter" ( ⌼) para permitir a definição compacta de algumas seqüências recursivas.

O caso monádico ("unário") ⌼é basicamente de Haskell iteratee é definido como (F⌼) A ≡ A, (F A), (F (F A)), …. A ( "binário") caso dyadic é definido um pouco analogamente para duas variáveis: A (F⌼) B ≡ A, B, (A F B), (B F (A F B)), …. Por que isso é útil? Bem, como se vê, esse é precisamente o tipo de recorrência da sequência de Fibonacci. De fato, um dos exemplos dados é

1+⌼1

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

Então, lá está, possivelmente a menor implementação possível de Fibonacci em uma linguagem de programação que não é novidade. : D

R, 40 bytes

Não vi uma solução R, então:

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

05AB1E, 7 bytes

Código:

1$<FDr+

Experimente online!

Dodos , 26 bytes

	dot F
F
	F dip
	F dip dip

Experimente online!

Como funciona

A função F faz todo o trabalho pesado; é 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 ; se n = 1 , então || n - 1 | 1 | = | 0 - 1 | = 1 = 1 . Nos dois 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, a função principal é definida como

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

por isso acrescenta-se todas as coordenadas do vetor retornado por F .

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

GolfScript, 13 caracteres

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

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

Desmos , 61 bytes

Golfe

Clique no add sliderbotã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 concorrente porque o idioma é mais recente que a pergunta.

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

;.o.ON/+!)

Experimente online

Isso envolve um cubo 2 x 2 da seguinte maneira

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

• O emitir o valor dos TOS
• N empurrar nova linha para a pilha
• / refletir norte
• o gera o caractere do TOS
• ; pop TOS
• / refletir leste depois de dar a volta no cubo
• + adicione os 2 principais valores da pilha
• ! pule o próximo comando se o TOS for 0
• ) aumente os TOS em 1. Isso inicia a sequência essencialmente.

Esse é um loop sem fim que imprime a sequência com um separador de nova linha. Aproveita o fato de a maioria dos comandos não exibir os valores da pilha.
Se o separador for ignorado, isso poderá 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 que o acima.

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

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