Perl 6, 10 caratteri:

Elenco di sequenze di 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 dallelenco anonimo stesso:

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

Ciò restituisce:

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 qualche semplice benchmark:

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

Con:

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

EOF

Commenti

• Non ' nemmeno pensare di ^2 in sostituzione di 0,1. +1
• Questo non è più valido, dovrai scriverlo come |^2,*+*...*, che è lo stesso numero di byte di 0,1,*+*...*.
• Perl è così strano.
• In quale versione di Perl 6 è stata scritta questa risposta?
• @CalculatorFeline Cè stato un grande cambiamento noto come GLR (Great List Refactor) che è avvenuto poco prima del primo rilascio ufficiale che è stato il 25/12/2015. Questo codice avrebbe funzionato fino a quel momento.

Brainfuck, 22 colpi

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

Genera la sequenza di Fibonacci spostandosi gradualmente sul nastro di memoria.

Commenti

• Bello ! Letteralmente bello! O forse no … comunque +1 per questo 🙂
• Questo è 3,344 o 4 byte in brainfuck compresso. (6 ln (22)) / ln (256)
• 16 byte: +[[<+>->+>+<<]>]
• 14 byte: +[.[>+>+<<-]>]
• @Stefnotch ovviamente, quello più corto è distruttivo. La soluzione sopra termina con la sequenza di Fibonacci sul nastro, che è ciò che fa anche la soluzione a 16 byte.

Haskell, 17 15 14 caratteri

f=1:scanl(+)1f 

Provalo online!

Commenti

• Perché non tagliare due spazi a f=0:scanl(+)1 f?
• @Martinho: modificato, grazie.
• Wow, che ' è ancora più corto del solito f@(_:x)=0:1:zipWith(+)f x! Devo ricordarlo.
• Potresti anche eliminare un altro spazio: f=0:scanl(+)1f.

C # 4, 58 byte

Stream (69; 65 se digitato in modo debole in IEnumerable)

(Supponendo una using direttiva 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);} 

Commenti

• Dato che n è un uint, n==0 può essere abbreviato in n<1. E lo stream può salvare alcuni caratteri eliminando lo spazio dopo il tipo generico e dichiarando x in un ambito più ampio del necessario.In effetti, elimina completamente x: n+=c;c=n-c;
• @Peter: Grazie, modificherò quando avrò un po di tempo.
• La tua versione a valore singolo è lunga quanto la mia risposta espressione lambda ricorsiva … bello!
• @ wizzwizz4 se ' non sbaglio, se !n funziona, allora dovrebbe n capovolgere il condizionale.
• @JonSkeet Aw. E qui stavo pensando di aver ' battuto Jon Skeet in C # … 🙂

GolfScript, 12

Ora, solo 12 caratteri!

1.{[email protected]+.}do 

Commenti

• +1 bel lavoro. Se lo rendi più corto di 13 caratteri, ' accetto immediatamente la tua risposta (a meno che qualcuno non dia una risposta ancora più breve, ovviamente). 😛
• Amo le sfide. Fatto! 😉
• Bello, hai vinto. Almeno, finché qualcuno non crea qualcosa di ancora più corto (se questo ' è anche possibile). 😛
• quella definizione è breve quasi quanto il nome ' Fibonacci ' stesso! +1

J, 10 caratteri

Utilizzo del calcolo integrato di Coefficienti della serie di Taylor quindi forse poco a buon mercato. Lho imparato qui .

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

Commenti

• @aditsu (q:^-^:p) 6 è 64 729 dove p è pari. J è probabilmente buono per quello che fa enigmi. 🙂
• Ancora meglio: (<:^-^:>) 4 è 81 e <:^-^:> 4 è 53.5982.
• Lemoji mostrato qui è ciò a cui dovrebbe tendere tutto il codice J. Come nota a margine, unaltra alternativa è +/@:!&i.- utilizzando 9 byte.
• @miles Very nice! Dovresti pubblicarlo perché è completamente diverso dal mio.

> < > – 15 caratteri

0:nao1v a+@:n:<o 

Commenti

• Anche se puoi abbreviarlo a 0:nao1v LF a+@:n:<o se lo desideri. Fornisce 15 🙂 In effetti, questo rende anche loutput leggermente più leggibile …
• 13 caratteri: 01r:nao$:@+$r

Esagonia , 18 14 12

Grazie Martin per 6 byte!

1="/}.!+/M8; 

Espanso:

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

Provalo online

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

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

Espanso:

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

Questo stampa la sequenza di Fibonacci separata da nuove righe.

Provalo online! Fai attenzione però, il allinterprete non piace molto loutput infinito.

Spiegazione

Ci sono due “subroutine” in questo programma, ognuna è eseguita da uno dei due IP utilizzati. La prima routine stampa le nuove righe e la seconda esegue il calcolo e loutput 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 a zero), e quindi incrementa il valore al puntatore di memoria di 1. Dopo il no-op, lIP salta alla terza riga che prima passa a unaltra cella di memoria, quindi stampa una nuova riga. una nuova riga ha un valore positivo (il suo valore è 10), th Il codice salterà sempre alla quinta riga, successiva. La quinta riga restituisce il puntatore di memoria al nostro numero di Fibonacci e quindi passa allaltra subroutine. Quando torniamo da questa subroutine, lIP tornerà alla terza riga, dopo aver eseguito una no-op.

La seconda subroutine inizia nellangolo in alto a destra e inizia a muoversi verso sud-est. Dopo un no-op, siamo spinti a viaggiare verso ovest lungo la seconda linea. Questa riga stampa il numero di Fibonacci corrente, prima di spostare il puntatore di memoria nella posizione successiva. Quindi lIP salta alla quarta riga, dove calcola il numero di Fibonacci successivo utilizzando i due precedenti. Dà quindi il controllo alla prima subroutine, ma quando riprende il controllo del programma, continua fino a quando non incontra un salto, dove rimbalza sullo specchio che era originariamente utilizzato per puntarlo ad Ovest, mentre ritorna sulla seconda riga.

Preliminary Pretty Pictures!

Il lato sinistro dellimmagine è il programma, il lato destro rappresenta la memoria. La casella blu è il primo IP ed entrambi gli IP puntano alla successiva istruzione da eseguire.

Nota: le immagini possono apparire carino solo a persone che hanno abilità altrettanto limitate con i programmi di modifica delle immagini: PI aggiungerà almeno altre 2 iterazioni in modo che luso delloperatore * diventi più chiaro.

Nota 2: ho visto solo la risposta di alephalpha “ dopo aver scritto la maggior parte di questo, ho pensato che fosse ancora prezioso a causa della separazione, ma lattuale Fibonacci parti 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 sarebbe stato utile tenerlo comunque: P

Commenti

• Dovresti creare un link a qualunque cosa hai usato per realizzare le belle immagini, quindi inserire il link in esolangs.org/wiki/ Hexagony .
• @ mbomb007 Ho usato gimp per creare manualmente ogni frame, quindi ho caricato le immagini su alcuni gi f fare sito web. Tuttavia, diverse volte durante questo processo ho pensato di creare uno strumento per farlo, considerando quanto fosse noioso.
• @FryAmTheEggman Impressionante! Rendila una sfida. Sono ' sono sicuro che qualcuno pubblicherà una risposta. : D Ancora meglio se potessi creare un sito web simile a fish ' s online interpreter.
• @ mbomb007 Potrebbe essere un po ambizioso una sfida su questo sito , per non parlare del fatto che probabilmente soffrirebbe molto se fosse molto ampio. Non ' penso che lo posterò, ma sentiti libero di farlo tu stesso se pensi di avere un buon modo di presentarlo. Inoltre, credo che Timwi abbia creato un ide C # per lesagonia, anche se ' non lho mai usato perché ' non mi sono preoccupato del mono.
• @ mbomb007 Lide vive qui , a proposito, lultima volta si è dimenticato di collegarlo.

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 byte

Python, usando la ricorsione … qui arriva uno StackOverflow!

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

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

^‡ ¡ sbircia i due link a sinistra. Poiché ce nè solo uno, deve essere il corpo del ciclo. Pertanto, un numero viene letto dallinput. Poiché non ci sono argomenti della riga di comando, quel numero viene letto da STDIN.

Esagonia , 6 byte

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

1.}=+! 

Ungolfed:

 1 . } = + ! . 

Stampa la sequenza di Fibonacci senza alcun separatore.

Commenti

• Questo ha il problema minore che ' t non stampa alcun separatore tra i numeri. Tuttavia, questo non è ' completamente ben specificato nella sfida. (E io ' sono davvero felice che qualcuno stia usando Hexagony. :))

Golfscript – numero singolo – 11/12/10

12 caratteri per ricevere input da stdin:

~0 1@{.@+}*; 

11 caratteri per linput già nello stack:

0 1@{.@+}*; 

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

1.@{.@+}*; 

Commenti

• Lopzione è " Calcola, dato n, lennesimo numero di Fibonacci ". Quindi elimina ~ e avrai 11 caratteri che prendono n nello stack e lascia F_n in pila.

Ruby

29 27 25 24 caratteri

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

Modifica: ha reso un ciclo infinito. 😉

Commenti

• qualcuno ha notato che b=a+a=b è un palindromo? 🙂
• sì st0le lha fatto 🙂
• So di ' sono in ritardo alla festa, ma qualcuno può spiegare come b=a+a=b parte funziona? ' sembra che non mi capiti.
• @GigaWatt, pensala in questo modo, le istruzioni vengono eseguite da sinistra a destra …quindi newb=olda+(a=oldb)
• puoi salvare 2 caratteri utilizzando loop: p 1,a=b=1;loop{p b=a+a=b}

DC (20 byte)

Come bonus, “è persino offuscato;)

zzr[dsb+lbrplax]dsax 

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

Commenti

• ' non lo chiamerei offuscato – codice offuscato dovrebbe essere difficile da capire e, per quanto riguarda dc, il codice qui è completamente semplice.

Mathematica, 9 caratteri

Fibonacci 

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

Mathematica, 33 32 31 caratteri

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

Commenti

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

Prelude , 12 byte

Una delle poche sfide in cui Prelude è effettivamente abbastanza competitivo:

1(v!v) ^+^ 

Ciò richiede linterprete Python che stampa i valori come numeri decimali invece che caratteri.

Spiegazione

In Prelude, tutte le righe vengono eseguite in parallelo, con il puntatore dellistruzione che attraversa le colonne del programma. Ogni riga ha il proprio stack che viene inizializzato a 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 ciclo si ripete per sempre, perché il primo stack non avrà mai un 0 sopra.

Nota che questo avvia la sequenza di Fibonacci da 0.

TI-BASIC, 11

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

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

Per utilizzare:

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

Come funziona? Se fai i conti, risulta che sinh‾¹(.5) è uguale a ln φ, quindi è “una versione modificata della formula di Binet” che arrotonda per difetto invece di utilizzare il (1/φ)^n termine di correzione. Il round( (arrotondato a 9 cifre decimali) è necessario per evitare errori di arrotondamento.

K – 12

Calcola il n e n-1 numero di Fibonacci.

{x(|+\)/0 1} 

Solo il nth numero di Fibonacci.

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

Commenti

• +1 Non male! Se potessi ridurlo di un solo carattere (e fornirmi un modo per testarlo), ' accetterò la tua risposta. 🙂
• Lunico modo per ridurlo sarebbe sostituire la funzione con una chiamata a un numero noto: n (| + \ ) / 0 1 Provalo utilizzando questo interprete .

Java, 55

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

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

n è linput (int o long), che inizia con n = 1. Utilizza Binet “s formula e arrotonda invece della sottrazione.

Commenti

• Mi piace questa soluzione
• Non ' sembra funzionare per me, ma ' è presto e potrei essere manca qualcosa! Supponendo che 0 sia il primo numero nella sequenza, questo restituisce 0, 0, 1, 1, 3, 4, 8, 12, 21, 33 per i primi t 10 numeri
• @Shaggy Oops! Spiacenti, ho introdotto un bug – risolto ora.

Julia, 18 byte

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

Dodos , 26 byte

	dot F F 	F dip 	F dip dip 

Provalo online!

Come funziona

La funzione F fa tutto il lavoro pesante; è definito ricorsivamente 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 restituisce (F (n – 1), F (n – 2)) .

Se n = 0 , quindi | n – 1 | = 1> 0 ; se n = 1 , allora || n – 1 | – 1 | = | 0 – 1 | = 1 = 1 . In entrambi i casi, i tentativi di chiamata ricorsiva F (1) sollevano uneccezione Surrender , 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, main la funzione è definita come

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

quindi somma tutte le coordinate del vettore restituito di F .

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

Commenti

• Ho letto il tuo README (DODOS) e sono molto incuriosito; è davvero un bel concetto! Ma non riesco a trovarlo su Esolangs o altrove. Lhai inventato?

Ruby, 25 caratteri

st0le “risposta abbreviata.

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

Commenti

• In realtà puoi accorciarla ulteriormente utilizzando a=b=1;loop{p a;b=a+a=b}
• Quindi scegli la sua risposta?: P

FAC: APL funzionale, 4 caratteri (!!)

Non mio, quindi pubblicato come wiki della comunità. FAC è un dialetto di APL che Hai-Chen Tu apparentemente ha suggerito come sua tesi di dottorato nel 1985. In seguito scrisse un articolo insieme ad Alan J. Perlis intitolato “ FAC: A Functional APL Language “. Questo dialetto di APL utilizza “lazy array” e consente array di lunghezza infinita. Definisce un operatore “iter” (⌼) per consentire la definizione compatta di alcune sequenze ricorsive.

Il monadico (“unario “) il caso di ⌼ è fondamentalmente Haskell” s ed è definito come (F⌼) A ≡ A, (F A), (F (F A)), …. Il caso diadico (“binario”) è definito in modo alquanto analogo 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 

che produce la sequenza familiare 1 1 2 3 5 8 ….

Quindi, ecco qua, molto probabilmente limplementazione di Fibonacci più breve possibile in un linguaggio di programmazione non innovativo. : D

Commenti

• Oh, ho accidentalmente rimosso il wiki dal tuo post come parte del mio (manuale) bulk-unfikiing. Vabbè. 😉

R, 40 byte

Non ho visto un Soluzione R, quindi:

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

Commenti

• So che questa è una vecchia risposta, ma tu può essere ridotto a 38 byte

05AB1E, 7 byte

Codice:

1$<FDr+ 

Provalo online!

Commenti

• Ciao e benvenuto in PPCG! Bel primo post!

GolfScript, 13 caratteri

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

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

Desmos , 61 byte

Golfed

Fai clic sul pulsante add slider pulsante per n.

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

Lultima riga è loutput.

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 in competizione perché la lingua è più recente della domanda.

Cubix è un nuovo linguaggio bidimensionale di @ETHproductions dove il codice è avvolto in un cubo di dimensioni adeguate.

;.o.ON/+!) 

Provalo online

Questo si conclude con un 2 x 2 cubo nel modo seguente

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

• O restituisce il valore del TOS
• N invia nuova riga nello stack
• / riflette il nord
• o restituisce il carattere del TOS
• ; pop TOS
• / riflettere verso est dopo aver girato intorno al cubo
• + aggiungi i primi 2 valori della pila
• ! salta il comando successivo se il TOS è 0
• ) incrementa il TOS di 1. Questo essenzialmente dà il via alla sequenza.

Questo è un ciclo infinito che stampa la sequenza con un separatore di nuova riga. 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 quella sopra.

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

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

Commenti

• Questo va bene, ma non sarebbe corretto nel dire che la versione a 14 byte esce solo dal 2 ° 1 in poi? Come in " 1 2 3 5 8 " invece di " 1 1 2 3 5 8 "?
• @Charlim Oh, tu ' hai ragione. Non ho idea di cosa pensasse il me del 2014. Comunque, lho appena risolto con mov inserendo listruzione di stampa allinizio del ciclo.