Perl 6, 10 tecken:

Anonym oändlig lista med פיבotliga sekvenser:

^2,*+*...* 

Samma som:

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

Så du kan tilldela den till en matris:

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

eller

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

Och få de första elva värdena (från 0 till 10) med:

say @short-fibs[^11]; 

eller med:

say @fibs[^11]; 

Vänta, du kan få de första 50 siffrorna från den anonyma listan själv:

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

Det returnerar:

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 

Och några enkla riktmärken:

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

Med:

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

EOF

Kommentarer

• Jag skulle inte ens tänka ' av ^2 som ersättning för 0,1. +1
• Detta är inte längre giltigt, du måste skriva det som |^2,*+*...*, vilket är samma antal byte som 0,1,*+*...*.
• Perl är så konstig.
• Vilken version av Perl 6 var detta svar skrivet i?
• @CalculatorFeline Det skedde en stor förändring känd som GLR (Great List Refactor) som hände strax före den första officiella utgåvan som var 2015-12-25. Den här koden skulle ha fungerat ända fram till den tiden.

Brainfuck, 22 drag

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

Genererar Fibonacci-sekvensen som gradvis rör sig över minnesbandet.

Kommentarer

• Vacker ! Litteralt vacker! Eller kanske inte … hur som helst +1 för detta 🙂
• Det här är 3.344 eller 4 byte i komprimerad hjärnfuck. (6 ln (22)) / ln (256)
• 16 byte: +[[<+>->+>+<<]>]
• 14 byte: +[.[>+>+<<-]>]
• @Stefnotch naturligtvis, den kortare är destruktiv. Lösningen ovan avslutas med Fibonacci-sekvensen på bandet, vilket är vad 16 byte-lösningen också gör.

Haskell, 17 15 14 tecken

f=1:scanl(+)1f 

Prova online!

Kommentarer

• Varför inte klippa två mellanslag till f=0:scanl(+)1 f?
• @Martinho: Redigerad, tack.
• Wow, att ' är ännu kortare än den vanliga f@(_:x)=0:1:zipWith(+)f x! Måste komma ihåg det.
• Du kan till och med ta bort ett annat mellanslag: f=0:scanl(+)1f.

C # 4, 58 byte

Ström (69; 65 om svagt skrivs till IEnumerable)

(förutsatt att ett using -direktiv för System.Collections.Generic.)

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

Enstaka värde (58)

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

Kommentarer

• Med tanke på att n är en uint, n==0 kan förkortas till n<1. Och strömmen kan spara några tecken genom att släppa utrymmet efter den generiska typen och förklara x i ett större omfång än nödvändigt.Faktiskt, dike x helt: n+=c;c=n-c;
• @Peter: Tack, kommer att redigera när jag får lite tid.
• Din enda värdeversion är så länge som mitt rekursiva lambdauttryck svarar … trevligt!
• @ wizzwizz4 om jag ' inte felaktigt, om !n fungerar, så borde det bara vara n om du vänder på villkoret.
• @JonSkeet Aw. Och här tänkte jag att jag ' slog Jon Skeet på C # … 🙂

GolfScript, 12

Nu, bara 12 tecken!

1.{[email protected]+.}do 

Kommentarer

• +1 trevligt arbete. Om du gör det kortare än 13 tecken accepterar jag ' omedelbart ditt svar (såvida inte någon naturligtvis svarar ännu kortare). 😛
• Jag älskar en utmaning. Gjort! 😉
• Trevligt, du vinner. Åtminstone tills någon gör något ännu kortare (om det ' är möjligt). 😛
• den definitionen är nästan lika kort som namnet ' Fibonacci ' själv! +1

J, 10 tecken

Med hjälp av inbyggd beräkning av Taylor-seriekoefficienter så kanske lite fuskiga. Lärde det här .

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

Kommentarer

• @aditsu (q:^-^:p) 6 är 64 729 där p är jämnt. J är förmodligen bra för vad det gör gåtor. 🙂
• Ännu bättre: (<:^-^:>) 4 är 81 och <:^-^:> 4 är 53.5982.
• Den emoji som visas här är vad all J-kod ska sträva efter. På en sidoteckning är ett annat alternativ +/@:!&i.- med 9 byte.
• @miles Mycket trevligt! Du borde lägga upp det eftersom det skiljer sig helt från mitt.

> < > – 15 tecken

0:nao1v a+@:n:<o 

Kommentarer

• Även om du kan förkorta det till 0:nao1v LF a+@:n:<o om du vill. Ger 15 🙂 I själva verket gör detta också produktionen något mer läsbar …
• 13 tecken: 01r:nao$:@+$r

Hexagony , 18 14 12

Tack Martin för 6 byte!

1="/}.!+/M8; 

Utökat:

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

Prova online

Gammalt, svar. Detta lämnas kvar eftersom bilderna och förklaringen kan vara till hjälp för nya Hexagony-användare.

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

Utökat:

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

Detta skriver ut Fibonacci-sekvensen åtskilda av nya rader.

Prova det online! Var dock försiktig online tolk gillar inte oändlig produktion.

Förklaring

Det finns två ”underrutiner” till detta program, var och en körs av en av de två använda IP: erna. Den första rutinen skriver ut nya rader , och den andra gör Fibonacci-beräkningen och utmatningen.

Den första underrutinen börjar på första raden och flyttas åt vänster till höger hela tiden. Den skriver först ut värdet vid minnepekaren (initialiserad till noll), och sedan ökar värdet vid minnepekaren med 1. Efter no-op hoppar IP: n till den tredje raden som först växlar till en annan minnescell och sedan skriver ut en ny rad. en ny linje har ett positivt värde (dess värde är 10), th e-koden hoppar alltid till femte raden, nästa. Den femte raden returnerar minnepekaren till vårt Fibonacci-nummer och växlar sedan till den andra subrutinen. När vi kommer tillbaka från denna underrutin hoppar IP: n tillbaka till den tredje raden efter att ha utfört en no-op.

Den andra subrutinen börjar i det övre högra hörnet och börjar flytta sydost. Efter ett no-op, studsas vi för att resa västerut längs andra raden. Denna rad skriver ut det aktuella Fibonacci-numret innan minnepekaren flyttas till nästa plats. Sedan hoppar IP: n till fjärde raden, där den beräknar nästa Fibonacci-nummer med de två föregående. Det ger sedan kontroll tillbaka till den första subrutinen, men när den återfår kontrollen över programmet fortsätter den tills den möter ett hopp, där den studsar över spegeln som ursprungligen användes för att peka den väster, när den återvänder till andra raden.

Preliminära vackra bilder!

Bildens vänstra sida är programmet, den högra sidan representerar minnet. Den blå rutan är den första IP-adressen, och båda IP-adresserna pekar på nästa instruktion som ska köras.

Obs! Bilder kan komma verkar bara vacker för personer som har lika begränsad skicklighet med bildredigeringsprogram: PI kommer att lägga till minst två iterationer så att användningen av * operatören blir tydligare.

Anmärkning 2: Jag såg bara alephalpha ”svar efter att ha skrivit det mesta av detta, jag tänkte att det fortfarande var värdefullt på grund av separationen, men den faktiska Fibonacci delar av våra program är väldigt lika. Dessutom är detta det minsta Hexagony-programmet som jag har sett använda mer än en IP, så jag trodde att det kunde vara bra att behålla ändå: P

Kommentarer

• Du bör länka till vad du använde för att göra de vackra bilderna och sätt sedan länken på esolangs.org/wiki/ Hexagony .
• @ mbomb007 Jag använde gimp för att manuellt skapa varje ram och laddade sedan upp bilderna till lite gi f gör webbplats. Även om jag flera gånger under denna process övervägde att skapa ett verktyg för att göra det med tanke på hur tråkigt det var.
• @FryAmTheEggman Imponerande! Gör det till en utmaning. Jag ' är säker på att någon kommer att lägga upp ett svar. : D Ännu bättre om du skulle kunna skapa en webbplats som liknar fisk ' s online-tolk.
• @ mbomb007 Det kan vara lite ambitiöst för en utmaning på den här webbplatsen , för att inte tala om det skulle förmodligen lida mycket av att vara riktigt bred. Jag tror inte ' att jag kommer att lägga upp det, men gör gärna det själv om du tycker att du har ett bra sätt att presentera det. Jag tror också att Timwi skapade en C # ide för hexagoni, även om jag ' aldrig har använt det för att jag inte har ' inte brytt mig om mono.
• @ mbomb007 Idet lever här , glömde förresten att länka det förra gången.

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, med rekursion … här kommer ett StackOverflow!

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

Jelly , 3 byte

+¡1 

Prova online!

Så fungerar 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. 

^‡ ¡ tittar på de två länkarna till vänster. Eftersom det bara finns en måste den vara slingans kropp. Därför läses ett tal från inmatningen. Eftersom det inte finns några kommandoradsargument läses det talet från STDIN.

Hexagony , 6 byte

Ej konkurrerande eftersom språket är nyare än frågan.

1.}=+! 

Ungolfed:

 1 . } = + ! . 

Den skriver ut Fibonacci-sekvensen utan någon avgränsare.

Kommentarer

• Detta har det mindre problemet att det ' inte skriver ut någon avgränsare mellan siffrorna. Detta är dock inte '. (Och jag ' är verkligen glad att någon använder Hexagony. :))

Ruby

29 27 25 24 tecken

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

Redigera: gjorde det till en oändlig slinga. 😉

Kommentarer

• märkte någon att b=a+a=b är en palindrom? 🙂
• ja st0le gjorde 🙂
• Jag vet att jag ' är sen till festen, men kan någon förklara hur b=a+a=b delar fungerar? Kan ' inte tycka linda mitt huvud runt det.
• @GigaWatt, Tänk på det så, instruktioner utförs från vänster till höger …så newb=olda+(a=oldb)
• kan du spara två tecken med loop: p 1,a=b=1;loop{p b=a+a=b}

DC (20 byte)

Som en bonus är det ”är till och med fördunklat;)

zzr[dsb+lbrplax]dsax 

EDIT: Jag kan påpeka att den skriver ut alla siffrorna i Fibonacci-sekvensen, om du väntar tillräckligt länge.

Kommentarer

• Jag skulle inte ' t kallar det fördunkelt – fördunklad kod är tänkt att vara svårt att förstå, och så långt dc går är koden här helt enkel.

Mathematica, 9 tecken

Fibonacci 

Om inbyggda funktioner är inte tillåtna, här är en tydlig lösning:

Mathematica, 33 32 31 tecken

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

Kommentarer

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

Prelude , 12 byte

En av få utmaningar där Prelude faktiskt är ganska konkurrenskraftig:

1(v!v) ^+^ 

Detta kräver Python-tolk som skriver ut värden som decimaltal istället för tecken.

Förklaring

I Prelude, alla rader körs parallellt, med instruktionspekaren som korsar kolumnerna i programmet. Varje rad har sin egen stack som initialiseras till noll.

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. 

Slingan upprepas för alltid, för den första stacken kommer aldrig att ha en 0 överst.

Observera att detta startar Fibonacci-sekvensen från 0.

TI-BASIC, 11

Av legendariska TI-BASIC golfare Kenneth Hammond (”Weregoose”), från den här webbplatsen . Körs i O (1) tid och anser 0 vara den 0: e termen för Fibonacci-sekvensen.

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

Att använda:

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

Hur fungerar det här? Om du gör matte visar det sig att sinh‾¹(.5) är lika med ln φ, så det är en modifierad version av Binets formel som avrundar istället för att använda (1/φ)^n korrigeringsterm. round( (runda till 9 decimaler) behövs för att förhindra avrundningsfel.

K – 12

Beräknar n och n-1 Fibonacci-nummer.

{x(|+\)/0 1} 

Bara nth Fibonacci-nummer.

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

Kommentarer

• +1 Inte illa! Om du kunde krympa det bara ett tecken (och ge mig ett sätt att testa det), accepterar jag ' ditt svar. 🙂
• Det enda sättet att krympa skulle vara att ersätta funktionen med ett samtal till ett känt nummer: n (| + \ ) / 0 1 Testa det med denna tolk .

Java, 55

Jag kan inte konkurrera med de flesta språkens sammanfattning här, men jag kan erbjuda ett väsentligt annorlunda och möjligen mycket snabbare (konstant tid) sätt att beräkna n-talet:

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

n är ingången (int eller lång), med början på n = 1. Den använder Binets formel och avrundar istället för subtraktionen.

Kommentarer

• Jag älskar den här lösningen
• Det här verkar inte ' men det ' är tidigt och jag kanske är saknar något! Förutsatt att 0 är första siffran i sekvensen, ger detta 0, 0, 1, 1, 3, 4, 8, 12, 21, 33 för firs t 10 siffror
• @Shaggy Oj! Tyvärr introducerade jag ett fel – fixat nu.

Julia, 18 byte

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

Dodos , 26 byte

	dot F F 	F dip 	F dip dip 

Prova online!

Hur det fungerar

Funktionen F gör alla tunga lyft; den definieras rekursivt enligt följande.

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

När n> 1 | n – 1 | = n – 1 < n och || n – 1 | – 1 | = | n – 1 – 1 | = n – 2 < n , så funktionen returnerar (F (n – 1), F (n – 2)) .

Om n = 0 , sedan | n – 1 | = 1> 0 ; om n = 1 , då || n – 1 | – 1 | = | 0 – 1 | = 1 = 1 . I båda fallen försöker de rekursiva samtalen F (1) ett undantag Surrender , så F (0) returnerar 0 och F (1) returnerar 1 .

Till exempel F (3) = (F (1), F (2)) = (1 , F (0), F (1)) = (1, 0, 1) .

Slutligen huvud -funktionen definieras som

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

så att den lägger till alla koordinater för den returnerade vektorn av F .

Till exempel main (3) = summa (F (3)) = summa (1, 0, 1) = 2 .

Kommentarer

• Jag läste din README (DODOS) och är väldigt intresserad; det är ett riktigt snyggt koncept! Men jag hittar det inte på Esolangs eller någon annanstans. Fick du det?

Ruby, 25 tecken

st0le ”svaret förkortat.

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

Kommentarer

• Du kan faktiskt förkorta det ytterligare med a=b=1;loop{p a;b=a+a=b}
• Så du svarar på hans svar?: P

R, 40 byte

Har inte sett en R-lösning, så:

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

Kommentarer

• Jag vet att detta är ett gammalt svar, men du kan förkortas till 38 byte

05AB1E, 7 byte

Kod:

1$<FDr+ 

Prova online!

Kommentarer

• Hej och välkommen till PPCG! Trevligt första inlägg!

GolfScript, 13 tecken

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

(Mitt svar från en tidigare Stack Overflow-fråga .)

Desmos , 61 byte

Golfed

Klicka på add slider -knapp för n.

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

Den sista raden är utdata.

Ungolfed

Är 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

Icke-konkurrerande svar eftersom språket är nyare än frågan.

Cubix är ett nytt tvådimensionellt språk av @ETHproductions där koden lindas på en kub som är dimensionerad för att passa.

;.o.ON/+!) 

Prova online

Detta slingrar sig på en 2 x 2 kub på följande sätt

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

• O mata ut värdet på TOS
• N tryck newline på stacken
• / reflektera norr
• o mata ut TOS
• ; pop-TOS
• / reflektera öster efter att ha gått runt kuben
• + lägg till topp 2-värden i stacken
• ! hoppa över nästa kommando om TOS är 0
• ) öka TOS med 1. Detta startar i huvudsak av sekvensen.

Detta är en oändlig slinga som skriver ut sekvensen med en ny linjeseparator. Det drar nytta av det faktum att de flesta kommandon inte tappar värdena från stacken.
Om avgränsaren ignoreras kan detta göras med 5 byte .O+!)

Brainfuck, 16,15, 14/13 tecken

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

Skapar Fibonacci-sekvensen och skriver inte ut någonting. Dessutom är den kortare än den ovan.

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

Detta en har 14 tecken men skriver ut ASCII-tecken med värdena i Fibonacci-sekvensen.

Kommentarer

• Det här är bra, men skulle jag vara felaktig genom att säga att versionen med 14 byte endast matas ut från andra 1: a? Som i " 1 2 3 5 8 " istället för " 1 1 2 3 5 8 "?
• @Charlim Åh, du ' har rätt. Jag har ingen aning om vad jag från 2014 trodde. Hur som helst, jag fixade det bara med mov genom att skriva ut instruktionen längst fram på slingan.