La sequenza di Fibonacci è una sequenza di numeri, in cui ogni numero nella sequenza è la somma dei due numeri che la precedono. I primi due numeri nella sequenza sono entrambi 1.

Ecco i primi termini

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

Scrivi il codice più breve che:

• Genera la sequenza di Fibonacci senza fine.

• Dato ncalcola il ntermine della sequenza. (1 o zero indicizzato)

È possibile utilizzare forme standard di input e output.

(Ho fornito entrambe le opzioni nel caso in cui una sia più facile da eseguire nella lingua scelta rispetto all'altra.)

Per la funzione che accetta un n, deve essere supportato un valore di ritorno ragionevolmente grande (il più grande numero di Fibonacci che si adatta alla dimensione della parola normale del tuo computer, come minimo).

Classifica

/* 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 caratteri:

Elenco sequenze fibonacci infinite anonime:

^2,*+*...*

Uguale a:

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

Quindi, puoi assegnarlo a un array:

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

o

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

E ottieni i primi undici valori (da 0 a 10) con:

say @short-fibs[^11];

o con:

say @fibs[^11];

Aspetta, puoi ottenere anche i primi 50 numeri dall'elenco anonimo stesso:

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

Che ritorna:

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 alcuni semplici benchmark:

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

Con:

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

EOF

Brainfuck, 22 colpi

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

Genera la sequenza di Fibonacci spostandosi gradualmente attraverso il nastro di memoria.

Haskell, 17 15 14 caratteri

f=1:scanl(+)1f

Provalo online!

C # 4, 58 byte

Stream (69; 65 se digitato debolmente IEnumerable)

(Supponendo una usingdirettiva per System.Collections.Generic.)

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

Valore singolo (58)

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

GolfScript, 12

Ora, solo 12 personaggi!

1.{.@.p+.}do

> <> - 15 caratteri

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

J, 10 caratteri

Utilizzando il calcolo integrato dei coefficienti della serie Taylor, quindi forse poco costoso. L'ho imparato qui .

   (%-.-*:)t.

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

Esagonia ,18 14 12

Grazie Martin per 6 byte!

1="/}.!+/M8;

Allargato:

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

Provalo online

Vecchio, rispondi. Questo viene lasciato perché le immagini e la spiegazione potrebbero essere utili ai nuovi utenti di Hexagony.

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

Allargato:

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

Questo stampa la sequenza di Fibonacci separata da newline.

Provalo online! Attenzione però, all'interprete online non piace davvero l'output infinito.

Spiegazione

Esistono due "subroutine" per questo programma, ognuna è gestita da uno dei due IP utilizzati. La prima routine stampa nuove righe e la seconda esegue il calcolo e l'output di Fibonacci.

La prima subroutine inizia sulla prima riga e si sposta da sinistra a destra per tutto il tempo. Prima stampa il valore sul puntatore di memoria (inizializzato su zero), quindi incrementa il valore sul puntatore di memoria di 1. Dopo la no-op, l'IP passa alla terza riga che passa prima a un'altra cella di memoria, quindi stampa una nuova riga. Poiché una nuova riga ha un valore positivo (il suo valore è 10), il codice passerà sempre alla quinta riga, successiva. La quinta riga riporta il puntatore di memoria al nostro numero di Fibonacci e quindi passa all'altra subroutine. Quando torniamo da questa subroutine, l'IP tornerà alla terza riga, dopo aver eseguito una no-op.

La seconda subroutine inizia nell'angolo in alto a destra e inizia a spostarsi a sud-est. Dopo una no-op, siamo fatti rimbalzare per viaggiare verso ovest lungo la seconda linea. Questa riga stampa l'attuale numero di Fibonacci, prima di spostare il puntatore della memoria nella posizione successiva. Quindi l'IP passa alla quarta riga, dove calcola il successivo numero di Fibonacci usando i due precedenti. Restituisce quindi il controllo alla prima subroutine, ma quando riprende il controllo del programma, continua fino a quando non incontra un salto, dove rimbalza sul mirror che era originariamente utilizzato per puntarlo a ovest, mentre ritorna alla seconda riga.

Belle immagini preliminari!

Il lato sinistro dell'immagine è il programma, il lato destro rappresenta la memoria. La casella blu è il primo IP ed entrambi gli IP indicano la prossima istruzione da eseguire.

Nota: le immagini possono apparire belle solo per le persone che hanno abilità analogamente limitate con i programmi di modifica delle immagini: PI aggiungerà almeno altre 2 iterazioni in modo che l'uso *dell'operatore diventi più chiaro.

Nota 2: Ho visto la risposta di alephalpha solo dopo aver scritto la maggior parte di questo, ho pensato che fosse ancora prezioso a causa della separazione, ma le parti effettive di Fibonacci dei nostri programmi sono molto simili. Inoltre, questo è il più piccolo programma Hexagony che ho visto fare uso di più di un IP, quindi ho pensato che potesse essere utile tenere comunque: P

MUCCA , 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 byte

Python, usando la ricorsione ... ecco un StackOverflow!

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

Gelatina , 3 byte

+¡1

Provalo online!

Come funziona

+¡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à una occhiata ai due collegamenti a sinistra. Poiché ce n'è solo uno, deve essere il corpo del loop. Pertanto, un numero viene letto dall'input. Poiché non ci sono argomenti della riga di comando, quel numero viene letto da STDIN.

Golfscript - numero singolo - 12/11/10

12 caratteri per ricevere input da stdin:

~0 1@{.@+}*;

11 caratteri per l'input già nello stack:

0 1@{.@+}*;

10 caratteri per definire ulteriormente 1 come numero 0 di Fibonacci:

1.@{.@+}*;

Rubino

29 27 25 24 Chars

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

Modifica: lo ha reso un ciclo infinito. ;)

Mathematica, 9 caratteri

Fibonacci

Se le funzioni integrate non sono consentite, ecco una soluzione esplicita:

Mathematica, 33 32 31 caratteri

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

DC (20 byte)

Come bonus, è persino offuscato;)

zzr[dsb+lbrplax]dsax

EDIT: posso sottolineare che stampa tutti i numeri nella sequenza fibonacci, se aspetti abbastanza a lungo.

Preludio , 12 byte

Una delle poche sfide in cui Prelude è in realtà abbastanza competitivo:

1(v!v)
  ^+^

Ciò richiede l'interprete Python che stampa i valori come numeri decimali anziché come caratteri.

Spiegazione

In Preludio, tutte le linee vengono eseguite in parallelo, con il puntatore dell'istruzione che attraversa le colonne del programma. Ogni riga ha il proprio stack inizializzato su 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.

Il loop si ripete per sempre, perché il primo stack non avrà mai un vantaggio 0.

Nota che questo avvia la sequenza di Fibonacci da 0.

Hexagony , 6 byte

Non competitiva perché la lingua è più recente della domanda.

1.}=+!

Ungolfed:

  1 .
 } = +
  ! .

Stampa la sequenza di Fibonacci senza alcun separatore.

TI-BASIC, 11

Dal leggendario golfista TI-BASIC Kenneth Hammond ("Weregoose"), da questo sito . Viene eseguito nel tempo O (1) e considera 0 come il 0 ° termine della sequenza di Fibonacci.

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

Usare:

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

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

Come funziona? Se fai la matematica, si scopre che sinh‾¹(.5)è uguale a ln φ, quindi è una versione modificata della formula di Binet che arrotonda invece di usare il (1/φ)^ntermine di correzione. Il round((arrotondamento al 9 decimale) è necessario per evitare errori di arrotondamento.

K - 12

Calcola il numero ne n-1Fibonacci.

{x(|+\)/0 1}

Solo il nthnumero di Fibonacci.

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

Julia, 18 byte

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

Java, 55

Non posso competere con la concisione della maggior parte delle lingue qui, ma posso offrire un modo sostanzialmente diverso e forse molto più veloce (tempo costante) per calcolare l'n-esimo numero:

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

nè l'input (int o long), che inizia con n = 1. Usa la formula e i round di Binet invece della sottrazione.

Rubino, 25 caratteri

la risposta di st0le è stata abbreviata.

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

FAC: APL funzionale, 4 caratteri (!!)

Non mio, quindi pubblicato come wiki della community. FAC è un dialetto di APL che Hai-Chen Tu apparentemente suggerì come sua tesi di dottorato nel 1985. In seguito scrisse un articolo con Alan J. Perlis intitolato " FAC: A Functional APL Language ". Questo dialetto di APL utilizza "array pigri" e consente array di lunghezza infinita. Definisce un operatore "iter" (⌼ ) per consentire la definizione compatta di alcune sequenze ricorsive.

Il caso monadico ("unario") ⌼è fondamentalmente di Haskell iterate, ed è definito come (F⌼) A ≡ A, (F A), (F (F A)), …. Il ( "binario") caso diadico è definito alquanto analogamente per due variabili: A (F⌼) B ≡ A, B, (A F B), (B F (A F B)), …. Perché è utile? Bene, a quanto pare questo è esattamente il tipo di ricorrenza che ha la sequenza di Fibonacci. In effetti, uno degli esempi forniti è

1+⌼1

producendo la sequenza familiare 1 1 2 3 5 8 ….

Quindi, ecco qua, probabilmente la più breve implementazione possibile di Fibonacci in un linguaggio di programmazione non novità. : D

R, 40 byte

Non ho visto una soluzione R, quindi:

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

05AB1E, 7 byte

Codice:

1$<FDr+

Provalo online!

Dodos , 26 byte

	dot F
F
	F dip
	F dip dip

Provalo online!

Come funziona

La funzione F fa tutto il sollevamento pesante; è definito in modo ricorsivo come segue.

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

Ogni volta che n> 1 , abbiamo | n - 1 | = n - 1 <n e || n - 1 | - 1 | = | n - 1 - 1 | = n - 2 <n , quindi la funzione ritorna (F (n - 1), F (n - 2)) .

Se n = 0 , allora | n - 1 | = 1> 0 ; se n = 1 , quindi || n - 1 | - 1 | = | 0 - 1 | = 1 = 1 . In entrambi i casi, il tentativo di ricorsiva chiama F (1) sollevare un Surrender eccezione, quindi F (0) restituisce 0 e F (1) restituisce 1 .

Ad esempio, F (3) = (F (1), F (2)) = (1, F (0), F (1)) = (1, 0, 1) .

Infine, la funzione principale è definita come

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

quindi si aggiunge tutte le coordinate del vettore restituito da F .

Ad esempio, main (3) = sum (F (3)) = sum (1, 0, 1) = 2 .

GolfScript, 13 caratteri

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

(La mia risposta da una precedente domanda di overflow dello stack .)

Desmos , 61 byte

golfed

Fare clic sul add sliderpulsante per n.

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

L'ultima riga è l'output.

Ungolfed

È una funzione.

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

Cubix , 10 byte

Risposta non competitiva perché la lingua è più recente della domanda.

Cubix è un nuovo linguaggio bidimensionale di @ETHproductions in cui il codice è racchiuso in un cubo dimensionato per adattarsi.

;.o.ON/+!)

Provalo online

Questo si avvolge su un cubo 2 x 2 nel modo seguente

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

• O emette il valore del TOS
• N spingere la nuova riga nello stack
• / riflettere a nord
• o emette il carattere del TOS
• ; pop TOS
• / rifletti ad est dopo aver fatto il giro del cubo
• + aggiungi i primi 2 valori dello stack
• ! salta il comando successivo se TOS è 0
• ) incrementare il TOS di 1. Ciò dà il via essenzialmente alla sequenza.

Questo è un ciclo infinito che stampa la sequenza con un separatore newline. Sfrutta il fatto che la maggior parte dei comandi non estrae i valori dallo stack.
Se il separatore viene ignorato, è possibile farlo con 5 byte.O+!)

Brainfuck, 16,15, 14/13 caratteri

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

Genera la sequenza di Fibonacci e non stampa nulla. Inoltre, è più corto di quello sopra.

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

Questo ha 14 caratteri ma stampa caratteri ASCII con i valori della sequenza di Fibonacci.