Perl 6, 10 tegn:

Anonym uendelig liste over liste over sekvenser for Fibonacci:

^2,*+*...* 

Samme som:

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

Så du kan tildele den til en matrix:

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

eller

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

Og få de første elleve værdier (fra 0 til 10) med:

say @short-fibs[^11]; 

eller med:

say @fibs[^11]; 

Vent, du kan også få de første 50 numre fra selve den anonyme liste:

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

Det returnerer:

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 

Og noget simpelt benchmark:

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

Med:

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

EOF

Kommentarer

• Jeg ville ikke ' ikke engang tænke af ^2 som erstatning for 0,1. +1
• Dette er ikke længere gyldigt, du bliver nødt til at skrive det som |^2,*+*...*, hvilket er det samme antal bytes som 0,1,*+*...*.
• Perl er så underlig.
• Hvilken version af Perl 6 blev dette svar skrevet i?
• @CalculatorFeline Der var en stor ændring kendt som GLR (Great List Refactor), der skete kort før den første officielle frigivelse, som var den 2015-12-25. Denne kode ville have fungeret lige indtil det tidspunkt.

Brainfuck, 22 slag

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

Genererer Fibonacci-sekvensen, der gradvist bevæger sig hen over hukommelsestapen.

Kommentarer

• Smuk ! Litteralt smuk! Eller måske ikke … alligevel +1 til dette 🙂
• Dette er 3.344 eller 4 bytes i komprimeret hjernefuck. (6 ln (22)) / ln (256)
• 16 bytes: +[[<+>->+>+<<]>]
• 14 bytes: +[.[>+>+<<-]>]
• @Stefnotch selvfølgelig, den kortere er destruktiv. Ovenstående løsning slutter med Fibonacci-sekvensen på båndet, hvilket er hvad 16 byte-løsningen også gør.

Haskell, 17 15 14 tegn

f=1:scanl(+)1f 

Prøv det online!

Kommentarer

• Hvorfor ikke klippe to mellemrum til f=0:scanl(+)1 f?
• @Martinho: Redigeret, tak.
• Wow, at ' er endnu kortere end den sædvanlige f@(_:x)=0:1:zipWith(+)f x! Må huske det.
• Du kan endda strippe et andet mellemrum: f=0:scanl(+)1f.

C # 4, 58 bytes

Stream (69; 65 hvis svagt skrevet til IEnumerable)

(forudsat et using -direktiv til System.Collections.Generic.)

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

Enkelt værdi (58)

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

Kommentarer

• I betragtning af at n er en uint, n==0 kan afkortes til n<1. Og strømmen kan gemme et par tegn ved at droppe rummet efter den generiske type og erklære x i et bredere omfang end nødvendigt.Faktisk grøft x helt: n+=c;c=n-c;
• @Peter: Tak, redigerer, når jeg får noget tid.
• Din version med en enkelt værdi er så længe mit rekursive lambda-udtryk svarer … dejligt!
• @ wizzwizz4 hvis jeg ' ikke forkert, hvis !n fungerer, så skal det bare være n, hvis du vender det betingede.
• @JonSkeet Aw. Og her tænkte jeg, at jeg ' slog Jon Skeet ved C # … 🙂

GolfScript, 12

Nu er det kun 12 tegn!

1.{[email protected]+.}do 

Kommentarer

• +1 dejligt arbejde. Hvis du gør det kortere end 13 tegn, accepterer jeg ' straks dit svar (medmindre nogen selvfølgelig svarer endnu kortere). 😛
• Jeg elsker en udfordring. Færdig! 😉
• Dejligt, du vinder. I det mindste indtil nogen gør noget endnu kortere (hvis det ' endda er muligt). 😛
• denne definition er næsten lige så kort som navnet ' Fibonacci ' selv! +1

J, 10 tegn

Brug af indbygget beregning af Taylor-serien koefficienter så måske lidt snydende. Lærte det her .

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

Kommentarer

• @aditsu (q:^-^:p) 6 er 64 729 hvor p er jævn. J er sandsynligvis godt for hvad det gør gåder. 🙂
• Endnu bedre: (<:^-^:>) 4 er 81 og <:^-^:> 4 er 53.5982.
• Den demonstrerede emoji her er, hvad alle J-koder skal stræbe efter. På en sidebemærkning er et andet alternativ +/@:!&i.- ved hjælp af 9 byte.
• @miles Meget flot! Du skal sende den, da den er helt forskellig fra min.

> < > – 15 tegn

0:nao1v a+@:n:<o 

Kommentarer

• Selvom du kan forkorte det til 0:nao1v LF a+@:n:<o hvis du vil. Giver 15 🙂 Faktisk gør dette også output lidt mere læsbart …
• 13 tegn: 01r:nao$:@+$r

Hexagony , 18 14 12

Tak Martin for 6 byte!

1="/}.!+/M8; 

Udvidet:

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

Prøv det online

Gammelt, svar. Dette efterlades, fordi billederne og forklaringen kan være nyttige for nye Hexagony-brugere.

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

Udvidet:

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

Dette udskriver Fibonacci-sekvensen adskilt af nye linjer.

Prøv det online! Vær dog forsigtig med online tolk kan ikke rigtig lide uendelig output.

Forklaring

Der er to “underrutiner” til dette program, der hver drives af en af de to anvendte IPer. Den første rutine udskriver nye linjer , og det andet foretager Fibonacci-beregning og output.

Den første subrutine starter på første linje og bevæger sig fra venstre mod højre hele tiden. Den udskriver først værdien ved hukommelsesmarkøren (initialiseret til nul), og derefter øger værdien ved hukommelsesmarkøren med 1. Efter no-op hopper IPen til den tredje linje, der først skifter til en anden hukommelsescelle og derefter udskriver en ny linje. en ny linje har en positiv værdi (dens værdi er 10), th e-kode springer altid til den femte linje, næste. Den femte linje returnerer hukommelsesmarkøren til vores Fibonacci-nummer og skifter derefter til den anden subrutine. Når vi kommer tilbage fra denne subrutine, springer IPen tilbage til tredje linje efter udførelse af en no-op.

Den anden subrutine begynder i øverste højre hjørne og begynder at bevæge sig sydøst. Efter en no-op hoppes vi for at rejse vest ad anden linje. Denne linje udskriver det aktuelle Fibonacci-nummer, før hukommelsesmarkøren flyttes til den næste placering. Derefter hopper IPen til den fjerde linje, hvor den beregner det næste Fibonacci-nummer ved hjælp af de to foregående. Derefter giver den kontrol tilbage til den første subrutine, men når den genvinder kontrollen over programmet, fortsætter det, indtil det møder et spring, hvor det hopper over spejlet, der oprindeligt blev brugt til at pege det mod vest, da det vender tilbage til anden linje.

Foreløbige smukke billeder!

Venstre side af billedet er programmet, højre side repræsenterer hukommelsen. Den blå boks er den første IP, og begge IPer peger på den næste instruktion, der skal udføres.

Bemærk: Billeder kan virker kun smuk for folk, der har samme begrænsede færdigheder med billedredigeringsprogrammer: PI tilføjer mindst 2 gentagelser, så brugen af * -operatøren bliver mere tydelig.

Note 2: Jeg så kun alephalphas svar efter at have skrevet det meste af dette, jeg regnede med at det stadig var værdifuldt på grund af adskillelsen, men den faktiske Fibonacci dele af vores programmer er meget ens. Desuden er dette det mindste Hexagony-program, som jeg har set brugt mere end en IP, så jeg tænkte, at det kunne være godt at beholde alligevel: P

Kommentarer

• Du skal linke til det, du brugte til at lave de smukke billeder, og derefter sætte linket på esolangs.org/wiki/ Hexagony .
• @ mbomb007 Jeg brugte gimp til manuelt at oprette hver ramme og uploadede derefter billederne til nogle gi f at lave websted. Skønt jeg flere gange i løbet af denne proces overvejede at lave et værktøj til at gøre det, i betragtning af hvor kedeligt det var.
• @FryAmTheEggman Imponerende! Gør det til en udfordring. Jeg ' er sikker på, at nogen vil sende et svar. : D Endnu bedre, hvis du kunne oprette et websted, der ligner fisk ' s online-tolk.
• @ mbomb007 Det er måske en smule ambitiøst for en udfordring på dette websted For ikke at nævne, ville det sandsynligvis lide meget af at være rigtig bred. Jeg tror ikke ' at jeg vil skrive det, men du er velkommen til at gøre det selv, hvis du synes, du har en god måde at præsentere det på. Jeg tror også, at Timwi skabte en C # ide til hexagony, selvom jeg ' aldrig har brugt det, fordi jeg ikke har ' ikke gidet med mono.
• @ mbomb007 Ideen lever her glemte forresten at linke den sidste gang.

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 ved hjælp af rekursion … her kommer en StackOverflow!

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

Jelly , 3 byte

+¡1 

Prøv det online!

Sådan fungerer det

+¡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. 

^‡ ¡ kigger på de to links til venstre. Da der kun er én, skal det være kroppen af sløjfen. Derfor læses et tal fra input. Da der ikke er nogen kommandolinjeargumenter, læses dette tal fra STDIN.

Hexagony , 6 byte

Ikke-konkurrerende, fordi sproget er nyere end spørgsmålet.

1.}=+! 

Ungolfed:

 1 . } = + ! . 

Den udskriver Fibonacci-sekvensen uden nogen separator.

Kommentarer

• Dette har det mindre problem, at det ikke ' ikke udskriver nogen separator mellem tallene. Dette er dog ikke ' ikke helt specificeret i udfordringen. (Og jeg ' er virkelig glad for, at nogen bruger Hexagony. :))

Ruby

29 27 25 24 tegn

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

Rediger: gjorde det til en uendelig løkke. 😉

Kommentarer

• bemærkede nogen b=a+a=b er et palindrom? 🙂
• ja st0le gjorde 🙂
• Jeg ved, at jeg ' kommer sent til festen, men kan nogen forklare, hvordan b=a+a=b del fungerer? Kan ' ikke synes at pakke mit hoved rundt om det.
• @GigaWatt, tænk på det på denne måde, instruktioner udføres fra venstre mod højre …så newb=olda+(a=oldb)
• kan du gemme 2 tegn ved hjælp af loop: p 1,a=b=1;loop{p b=a+a=b}

DC (20 byte)

Som en bonus er det “er endog tilsløret;)

zzr[dsb+lbrplax]dsax 

REDIGERING: Jeg kan påpege, at den udskriver alle tallene i Fibonacci-sekvensen, hvis du venter længe nok.

Kommentarer

• Jeg ville ikke ' ikke kalde det tilsløret – tilsløret kode formodes at være vanskelig at forstå, og så vidt DC går, er koden her helt ligefrem.

Mathematica, 9 tegn

Fibonacci 

Hvis indbyggede funktioner er ikke tilladt, her er en eksplicit løsning:

Mathematica, 33 32 31 tegn

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

Kommentarer

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

Prelude , 12 byte

En af de få udfordringer, hvor Prelude faktisk er ret konkurrencedygtig:

1(v!v) ^+^ 

Dette kræver Python-tolken , der udskriver værdier som decimaltal i stedet for tegn.

Forklaring

I Prelude, alle linjer udføres parallelt, hvor instruktionsmarkøren krydser programmets kolonner. Hver linje har sin egen stak, der initialiseres til nul.

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. 

Sløjfen gentages for evigt, fordi den første stak aldrig vil have en 0 øverst.

Bemærk, at dette starter Fibonacci-sekvensen fra 0.

TI-BASIC, 11

Af den legendariske TI-BASIC golfspiller Kenneth Hammond (“Weregoose”) fra dette site . Kører i O (1) tid og betragter 0 som den 0. Term for Fibonacci-sekvensen.

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

Brug:

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

Hvordan fungerer dette? Hvis du laver matematikken, viser det sig, at sinh‾¹(.5) er lig med ln φ, så det er en ændret version af Binets formel, der afrunder i stedet for at bruge (1/φ)^n korrektionsudtrykket. round( (runde til 9 decimaler) er nødvendig for at forhindre afrundingsfejl.

K – 12

Beregner n og n-1 Fibonacci-nummer.

{x(|+\)/0 1} 

Bare nth Fibonacci-nummer.

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

Kommentarer

• +1 Ikke dårligt! Hvis du kun kunne krympe det med et tegn (og give mig en måde at teste det på), accepterer jeg ' dit svar. 🙂
• Den eneste måde at krympe det på ville være at erstatte funktionen med et opkald til et kendt nummer: n (| + \ ) / 0 1 Test det ved hjælp af denne tolk .

Java, 55

Jeg kan ikke konkurrere med kortfattetheden af de fleste sprog her, men jeg kan tilbyde en væsentligt anden og muligvis meget hurtigere (konstant tid) måde at beregne det n-tal op:

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

n er input (int eller lang), startende med n = 1. Den bruger Binets formel og afrunder i stedet for subtraktionen.

Kommentarer

• Jeg elsker denne løsning
• Dette virker ikke ' virker ikke for mig, men det ' er tidligt, og jeg kan være mangler noget! Forudsat at 0 er det første tal i sekvensen, giver dette 0, 0, 1, 1, 3, 4, 8, 12, 21, 33 for firs t 10 tal
• @Shaggy Ups! Undskyld, jeg introducerede en fejl – rettet nu.

Julia, 18 byte

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

Dodos , 26 byte

	dot F F 	F dip 	F dip dip 

Prøv det online!

Sådan fungerer det

Funktionen F gør alt det tunge løft; den defineres rekursivt som følger.

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

Hver gang n> 1 | n – 1 | = n – 1 < n og || n – 1 | – 1 | = | n – 1 – 1 | = n – 2 < n , så funktionen returnerer (F (n – 1), F (n – 2)) .

Hvis n = 0 , derefter | n – 1 | = 1> 0 ; hvis n = 1 , så || n – 1 | – 1 | = | 0 – 1 | = 1 = 1 . I begge tilfælde rejser de forsøgte rekursive opkald F (1) en undtagelse Overgivelse , så F (0) returnerer 0 og F (1) returnerer 1 .

For eksempel F (3) = (F (1), F (2)) = (1 , F (0), F (1)) = (1, 0, 1) .

Endelig er hoved -funktion er defineret som

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

så den tilføjer alle koordinater for den returnerede vektor af F .

For eksempel main (3) = sum (F (3)) = sum (1, 0, 1) = 2 .

Kommentarer

• Jeg læste din README (DODOS) og er super fascineret; det er et rigtig pænt koncept! Men jeg kan ikke finde det på Esolangs eller andre steder. Kom du med det?

Ruby, 25 tegn

st0le “s svar forkortet.

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

Kommentarer

• Faktisk kan du forkorte det yderligere ved hjælp af a=b=1;loop{p a;b=a+a=b}
• Så du stiller hans svar?: P

R, 40 byte

Har ikke set en R-løsning, så:

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

Kommentarer

• Jeg ved, dette er et gammelt svar, men du kan afkortes til 38 bytes

05AB1E, 7 byte

Kode:

1$<FDr+ 

Prøv det online!

Kommentarer

• Hej og velkommen til PPCG! Dejligt første indlæg!

GolfScript, 13 tegn

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

(Mit svar fra et forrige Stack Overflow-spørgsmål .)

Desmos , 61 byte

Golfet

Klik på add slider knap til n.

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

Den sidste linje er output.

Ungolfed

Er en funktion.

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

Cubix , 10 byte

Ikke-konkurrerende svar, fordi sproget er nyere end spørgsmålet.

Cubix er et nyt 2-dimensionelt sprog fra @ETHproductions, hvor koden er pakket ind på en terning, der er dimensioneret til at passe.

;.o.ON/+!) 

Prøv det online

Dette pakkes ind på en 2 x 2 terning på følgende måde

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

• O output værdien af TOS
• N skub newline på stakken
• / reflekterer nord
• o output karakteren af TOS
• ; pop-TOS
• / reflekterer øst efter at have kørt rundt i terningen
• + tilføj top 2-værdier i stakken
• ! spring næste kommando over, hvis TOS er 0
• ) forøg TOS med 1. Dette starter i det væsentlige sekvensen.

Dette er en endeløs sløjfe, der udskriver sekvensen med en ny linieseparator. Det drager fordel af, at de fleste kommandoer ikke springer værdierne fra stakken.
Hvis separatoren ignoreres, kan dette gøres med 5 byte .O+!)

Brainfuck, 16,15, 14/13 tegn

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

Genererer Fibonacci-sekvensen og udskriver ikke noget. Også, er kortere end den ovenfor.

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

Dette den ene har 14 tegn, men udskriver ASCII-tegn med værdierne for Fibonacci-sekvensen.

Kommentarer

• Dette er godt, men ville jeg være forkert ved at sige, at 14 byte-versionen kun udsendes fra 2. 1? Som i " 1 2 3 5 8 " i stedet for " 1 1 2 3 5 8 "?
• @Charlim Åh, du ' har ret. Jeg har ingen idé om, hvad jeg fra 2014 troede. I hvert fald rettede jeg det bare med mov ved at udskrive instruktioner til fronten af sløjfen.