Perl 6, 10 tekens:

Anonieme oneindige fibonacci-reekslijst:

^2,*+*...* 

Hetzelfde als:

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

U kunt het dus aan een array toewijzen:

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

of

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

En haal de eerste elf waarden op (van 0 tot 10) met:

say @short-fibs[^11]; 

of met:

say @fibs[^11]; 

Wacht, je kunt ook de eerste 50 nummers uit de anonieme lijst zelf halen:

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

Dat geeft als resultaat:

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 

En een simpele benchmark:

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

Met:

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

EOF

Reacties

• Ik zou ' niet eens nadenken van ^2 als vervanging voor 0,1. +1
• Dit is niet langer geldig, u zult het moeten schrijven als |^2,*+*...*, wat hetzelfde aantal bytes is als 0,1,*+*...*.
• Perl is zo raar.
• In welke versie van Perl 6 was dit antwoord geschreven?
• @CalculatorFeline Er was een grote verandering bekend als GLR (Great List Refactor), die plaatsvond kort voor de eerste officiële release op 25-12-2015. Deze code zou tot die tijd hebben gewerkt.

Brainfuck, 22 slagen

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

Genereert de Fibonacci-reeks die geleidelijk over de geheugentape beweegt.

Opmerkingen

• Prachtig ! Letterlijk mooi! Of misschien niet … in ieder geval +1 hiervoor 🙂
• Dit is 3.344 of 4 bytes in gecomprimeerde hersenneuk. (6 ln (22)) / ln (256)
• 16 bytes: +[[<+>->+>+<<]>]
• 14 bytes: +[.[>+>+<<-]>]
• @Stefnotch natuurlijk, de kortere is destructief. De bovenstaande oplossing eindigt met de fibonacci-reeks op de tape, wat ook de 16 byte-oplossing doet.

Haskell, 17 15 14 tekens

f=1:scanl(+)1f 

Probeer het online!

Reacties

• Waarom knip je niet twee spaties naar f=0:scanl(+)1 f?
• @Martinho: bewerkt, bedankt.
• Wauw, die ' is nog korter dan de gebruikelijke f@(_:x)=0:1:zipWith(+)f x! Moet het onthouden.
• U kunt zelfs een andere spatie verwijderen: f=0:scanl(+)1f.

C # 4, 58 bytes

Stream (69; 65 indien zwak getypt naar IEnumerable)

(Ervan uitgaande dat een using instructie voor System.Collections.Generic.)

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

Enkele waarde (58)

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

Reacties

• Gegeven dat n is een uint, n==0 kan worden ingekort tot n<1. En de stream kan een paar tekens besparen door de spatie achter het generieke type weg te laten en x in een breder bereik te declareren dan nodig is.In feite, sloot x helemaal: n+=c;c=n-c;
• @Peter: Bedankt, zal bewerken wanneer ik wat tijd heb.
• Uw versie met één waarde is zo lang als mijn recursieve lambda-expressieantwoord … leuk!
• @ wizzwizz4 als ik ' niet vergis je, als !n werkt, dan zou dat ook moeten n als je de conditionele omdraait.
• @JonSkeet Aw. En hier dacht ik dat ik ' Jon Skeet had verslagen bij C # … 🙂

GolfScript, 12

Nu, slechts 12 tekens!

1.{[email protected]+.}do 

Reacties

• +1 mooi werk. Als je het korter maakt dan 13 tekens, ' accepteer ik je antwoord onmiddellijk (tenzij iemand natuurlijk een nog korter antwoord geeft). 😛
• Ik hou van een uitdaging. Gedaan! 😉
• Mooi, je wint. Tenminste, totdat iemand iets nog korter maakt (als dat ' überhaupt mogelijk is). 😛
• die definitie is bijna net zo kort als de naam ' Fibonacci ' zelf! +1

J, 10 tekens

Met behulp van ingebouwde berekening van Coëfficiënten van de Taylor-reeks dus misschien een beetje vals. Heeft het hier geleerd.

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

Reacties

• @aditsu (q:^-^:p) 6 is 64 729 waar p even is. J is waarschijnlijk goed voor wat het doet raadsels. 🙂
• Nog beter: (<:^-^:>) 4 is 81 en <:^-^:> 4 is 53.5982.
• De emoji die hier wordt gedemonstreerd, is waar alle J-code naar zou moeten streven. Even terzijde, een ander alternatief is +/@:!&i.- met 9 bytes.
• @miles Erg leuk! Je moet het posten aangezien het totaal anders is dan het mijne.

> < > – 15 tekens

0:nao1v a+@:n:<o 

Reacties

• Hoewel je het kunt inkorten tot 0:nao1v LF a+@:n:<o als u dat wilt. Geeft 15 🙂 In feite maakt dit de uitvoer ook iets leesbaarder …
• 13 tekens: 01r:nao$:@+$r

Hexagony , 18 14 12

Bedankt Martin voor 6 bytes!

1="/}.!+/M8; 

Uitgebreid:

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

Probeer het online

Oud, antwoord. Dit wordt achtergelaten omdat de afbeeldingen en uitleg nuttig kunnen zijn voor nieuwe Hexagony-gebruikers.

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

Uitgebreid:

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

Hiermee wordt de Fibonacci-reeks afgedrukt, gescheiden door nieuwe regels.

Probeer het online! Wees voorzichtig, de online interpreter houdt niet echt van oneindige output.

Uitleg

Er zijn twee “subroutines” voor dit programma, elk wordt uitgevoerd door een van de twee gebruikte IPs. De eerste routine drukt nieuwe regels af , en de tweede doet de Fibonacci-berekening en -uitvoer.

De eerste subroutine begint op de eerste regel en beweegt de hele tijd van links naar rechts. Het drukt eerst de waarde af bij de geheugenpointer (geïnitialiseerd op nul), en verhoogt vervolgens de waarde bij de geheugenpointer met 1. Na de no-op springt het IP-adres naar de derde regel die eerst naar een andere geheugencel schakelt en vervolgens een nieuwe regel afdrukt. een nieuwe regel heeft een positieve waarde (de waarde is 10), th De code springt altijd naar de vijfde regel, de volgende. De vijfde regel geeft de geheugenpointer terug naar ons Fibonacci-nummer en schakelt dan over naar de andere subroutine. Wanneer we terugkomen van deze subroutine, springt het IP terug naar de derde regel, na het uitvoeren van een no-op.

De tweede subroutine begint in de rechterbovenhoek en begint naar het zuidoosten te bewegen. Na een no-op worden we teruggestuurd om langs de tweede lijn naar het westen te reizen. Deze regel drukt het huidige Fibonacci-nummer af, voordat de geheugenpointer naar de volgende locatie wordt verplaatst. Vervolgens springt het IP naar de vierde regel, waar het het volgende Fibonacci-getal berekent met behulp van de vorige twee. Het geeft dan de controle terug aan de eerste subroutine, maar wanneer het de controle over het programma terugkrijgt, gaat het door totdat het een sprong ontmoet, waar het stuitert over de spiegel die oorspronkelijk werd gebruikt om het naar het westen te wijzen, terwijl het terugkeert naar de tweede regel.

Voorlopige mooie fotos!

De linkerkant van de afbeelding is het programma, de rechterkant vertegenwoordigt de herinnering. Het blauwe vak is het eerste IP-adres en beide IP-adressen wijzen naar de volgende instructie die moet worden uitgevoerd.

Opmerking: afbeeldingen kunnen lijken alleen mooi voor mensen die een vergelijkbare beperkte vaardigheid hebben met beeldbewerkingsprogrammas: PI zal minstens 2 extra iteraties toevoegen zodat het gebruik van de * operator duidelijker wordt.

Opmerking 2: ik zag alleen het antwoord van alephalpha “s antwoord nadat ik het meeste hiervan had geschreven, ik dacht dat het nog steeds waardevol was vanwege de scheiding, maar de werkelijke Fibonacci delen van onze programmas lijken erg op elkaar.Bovendien is dit het kleinste Hexagony-programma dat ik heb gezien met gebruik van meer dan één IP-adres, dus ik dacht dat het misschien goed zou zijn om toch te behouden: P

Opmerkingen

• Je zou moeten linken naar wat je gebruikt hebt om de mooie plaatjes te maken, en dan de link op esolangs.org/wiki/ plaatsen Hexagony .
• @ mbomb007 Ik heb gimp gebruikt om elk frame handmatig te maken, en vervolgens de afbeeldingen geüpload naar een gi f het maken van een website. Hoewel ik tijdens dit proces verschillende keren heb overwogen een hulpmiddel te maken om het te doen, gezien hoe vervelend het was.
• @FryAmTheEggman Indrukwekkend! Maak er een uitdaging van. Ik ' weet zeker dat iemand een antwoord zal posten. : D Nog beter als je een website zou kunnen maken die lijkt op fish ' s online interpreter.
• @ mbomb007 Dat is misschien een beetje ambitieus voor een uitdaging op deze site , om nog maar te zwijgen van het feit dat het waarschijnlijk veel zou lijden als het echt breed is. Ik denk niet dat ik ' niet zal posten, maar voel je vrij om het zelf te doen als je denkt dat je een goede manier hebt om het te presenteren. Ik geloof ook dat Timwi een C # ide voor hexagony heeft gemaakt, hoewel ik ' het nooit heb gebruikt omdat ik ' niet met mono bezig was.
• @ mbomb007 De ide leeft trouwens hier , vergat de vorige keer te koppelen.

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, met recursie … hier komt een StackOverflow!

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

Jelly , 3 bytes

+¡1 

Probeer het online!

Hoe het werkt

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

^‡ ¡ gluurt naar de twee links aan de linkerkant. Omdat er maar één is, moet het de kern van de lus zijn. Daarom wordt een nummer uit de invoer gelezen. Aangezien er geen opdrachtregelargumenten zijn, wordt dat nummer gelezen uit STDIN.

Hexagony , 6 bytes

Concurrerend omdat de taal nieuwer is dan de vraag.

1.}=+! 

Ungolfed:

 1 . } = + ! . 

Het drukt de Fibonacci-reeks af zonder enig scheidingsteken.

Opmerkingen

• Dit heeft het kleine probleem dat het ' geen scheidingsteken tussen de getallen afdrukt. Dit is echter niet ' t helemaal goed gespecificeerd in de challenge. (En ik ' ben erg blij dat iemand Hexagony gebruikt. :))

Golfscript – enkel nummer – 12/11/10

12 tekens voor het nemen van invoer van stdin:

~0 1@{.@+}*; 

11 tekens voor invoer die al op de stapel staan:

0 1@{.@+}*; 

10 tekens om 1 verder te definiëren als het 0e Fibonacci-getal:

1.@{.@+}*; 

Opmerkingen

• De optie is " Berekent, gegeven n, het n-de Fibonacci-getal ". Dus gooi de ~ weg en je hebt 11 tekens die n op de stapel nemen en laat F_n op de stapel.

Ruby

29 27 25 24 tekens

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

Bewerken: er een oneindige lus van gemaakt. 😉

Reacties

• heeft iemand opgemerkt dat b=a+a=b een palindroom is? 🙂
• ja st0le deed 🙂
• Ik weet dat ik ' laat op het feest ben, maar kan iemand uitleggen hoe de b=a+a=b deel werkt? Kan ' mijn hoofd er niet omheen slaan.
• @GigaWatt, Zie het op deze manier, instructies worden van links naar rechts uitgevoerd …dus newb=olda+(a=oldb)
• je kunt 2 tekens opslaan met loop: p 1,a=b=1;loop{p b=a+a=b}

DC (20 bytes)

Als bonus “s zelfs versluierd;)

zzr[dsb+lbrplax]dsax 

EDIT: ik mag erop wijzen dat het alle getallen in de fibonacci-reeks afdrukt, als je wacht lang genoeg.

Reacties

• Ik zou ' het niet versluierde – versluierde code noemen wordt verondersteld moeilijk te begrijpen te zijn, en wat dc betreft is de code hier volkomen duidelijk.

Mathematica, 9 tekens

Fibonacci 

Als ingebouwde functies zijn niet toegestaan, hier is een expliciete oplossing:

Mathematica, 33 32 31 tekens

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

Opmerkingen

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

Prelude , 12 bytes

Een van de weinige uitdagingen waar Prelude eigenlijk redelijk competitief is:

1(v!v) ^+^ 

Dit vereist de Python-interpreter die waarden afdrukt als decimale getallen in plaats van tekens.

Uitleg

In Prelude, alle regels worden parallel uitgevoerd, waarbij de instructieaanwijzer door de kolommen van het programma loopt. Elke regel heeft zijn eigen stapel die op nul wordt geïnitialiseerd.

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. 

De lus wordt voor altijd herhaald, omdat de eerste stapel nooit een 0 bovenaan zal hebben.

Merk op dat hiermee de Fibonacci-reeks begint vanaf 0.

TI-BASIC, 11

Door de legendarische TI-BASIC-golfer Kenneth Hammond (“Weregoose”), van deze site . Draait in O (1) tijd, en beschouwt 0 als de 0e term van de Fibonacci-reeks.

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

Te gebruiken:

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

Hoe werkt dit? Als je de wiskunde uitvoert, blijkt dat sinh‾¹(.5) gelijk is aan ln φ, dus het is een aangepaste versie van de formule van Binet die rondt naar beneden af in plaats van de (1/φ)^n correctieterm te gebruiken. De round( (afronden op 9 decimalen) is nodig om afrondingsfouten te voorkomen.

K – 12

Berekent het n en n-1 Fibonacci-getal.

{x(|+\)/0 1} 

Alleen het nth Fibonacci-nummer.

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

Reacties

• +1 Niet slecht! Als je het maar één teken zou kunnen verkleinen (en me een manier zou kunnen geven om het te testen), ' accepteer je antwoord. 🙂
• De enige manier om het te verkleinen is door de functie te vervangen door een aanroep naar een bekend nummer: n (| + \ ) / 0 1 Test het met deze tolk .

Java, 55

Ik kan hier “niet concurreren met de beknoptheid van de meeste talen, maar ik kan een wezenlijk andere en mogelijk veel snellere (constante tijd) manier aanbieden om het n-de getal te berekenen:

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

n is de invoer (int of long), beginnend met n = 1. Het gebruikt Binet “s formule en rondes in plaats van aftrekken.

Opmerkingen

• Ik hou van deze oplossing
• Dit lijkt ' t niet voor mij te werken, maar het is ' is vroeg en misschien ben ik er ontbreekt iets! Ervan uitgaande dat 0 het eerste nummer in de reeks is, geeft dit 0, 0, 1, 1, 3, 4, 8, 12, 21, 33 voor de eerste t 10 nummers
• @Shaggy Oeps! Sorry, ik heb een bug geïntroduceerd – nu opgelost.

Julia, 18 bytes

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

Dodos , 26 bytes

	dot F F 	F dip 	F dip dip 

Probeer het online!

Hoe het werkt

De functie F doet al het zware werk; het wordt als volgt recursief gedefinieerd.

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

Telkens n> 1 , hebben we | n – 1 | = n – 1 < n en || n – 1 | – 1 | = | n – 1-1 | = n – 2 < n , dus de functie retourneert (F (n – 1), F (n – 2)) .

Als n = 0 , daarna | n – 1 | = 1> 0 ; als n = 1 , dan || n – 1 | – 1 | = | 0 – 1 | = 1 = 1 . In beide gevallen veroorzaken de poging tot recursieve aanroepen F (1) een Surrender uitzondering, dus F (0) retourneert 0 en F (1) retourneert 1 .

Bijvoorbeeld F (3) = (F (1), F (2)) = (1 , F (0), F (1)) = (1, 0, 1) .

Ten slotte is de main functie is gedefinieerd als

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

dus het telt alle coördinaten van de geretourneerde vector op door F .

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

Opmerkingen

• Ik heb je README (DODOS) gelezen en ben super geïntrigeerd; het is een heel mooi concept! Maar ik kan het niet vinden op Esolangs of ergens anders. Heb je het bedacht?

Ruby, 25 tekens

st0le “s antwoord ingekort.

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

Reacties

• Eigenlijk kun je het nog verder inkorten met a=b=1;loop{p a;b=a+a=b}
• Dus je blijft op zijn antwoord staan?: P

FAC: Functionele APL, 4 karakters (!!)

Niet van mij, daarom gepost als community-wiki. FAC is een dialect van APL dat Hai-Chen Tu blijkbaar voorstelde als zijn proefschrift in 1985. Later schreef hij samen met Alan J. Perlis een artikel met de titel “ FAC: A Functional APL Language “. Dit dialect van APL gebruikt “lazy arrays” en staan arrays van oneindige lengte toe. Het definieert een operator “iter” (⌼) om een compacte definitie van sommige recursieve reeksen mogelijk te maken.

De monadische (“unaire “) geval van ⌼ is in feite Haskell” s , en wordt gedefinieerd als (F⌼) A ≡ A, (F A), (F (F A)), …. Het dyadische (“binaire”) geval wordt enigszins analoog gedefinieerd voor twee variabelen: A (F⌼) B ≡ A, B, (A F B), (B F (A F B)), …. Waarom is dit handig? Nou, het blijkt dat dit precies het soort herhaling is dat de Fibonacci-reeks heeft. In feite is een van de voorbeelden die ervan worden gegeven

1+⌼1 

en produceert de bekende reeks 1 1 2 3 5 8 ….

Dus alsjeblieft, misschien wel de kortst mogelijke Fibonacci-implementatie in een niet-nieuwe programmeertaal. : D

Reacties

• Oh, ik heb per ongeluk je bericht verwijderd uit de community als onderdeel van mijn (handmatige) bulk-uitwissen. Ach ja. 😉

R, 40 bytes

Ik heb geen R-oplossing, dus:

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

Reacties

• Ik weet dat dit een oud antwoord is, maar jij kan worden ingekort tot 38 bytes

05AB1E, 7 bytes

Code:

1$<FDr+ 

Probeer het online!

Reacties

• Hallo en welkom bij PPCG! Leuke eerste post!

GolfScript, 13 tekens

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

(Mijn antwoord van een vorige Stack Overflow-vraag .)

Desmos , 61 bytes

Golfed

Klik op de add slider knop voor n.

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

De laatste regel is de output.

Ungolfed

Is een functie.

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

Cubix , 10 bytes

Niet-concurrerend antwoord omdat de taal nieuwer is dan de vraag.

Cubix is een nieuwe tweedimensionale taal van @ETHproductions waar de code in een kubus wordt verpakt die zo groot is dat hij past.

;.o.ON/+!) 

Probeer het online

Dit loopt over in een 2 x 2 kubus op de volgende manier

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

• O voer de waarde van de TOS uit
• N nieuwe regel op stapel plaatsen
• / reflecteren noorden
• o voer het karakter van de TOS uit
• ; pop TOS
• / weerspiegelen het oosten nadat je rond de kubus bent gegaan
• + voeg de twee hoogste waarden van de stapel toe
• ! sla het volgende commando over als TOS 0 is
• ) verhoog de TOS met 1. Dit begint de reeks in wezen.

Dit is een eindeloze lus die de reeks afdrukt met een nieuwe-regelteken. Het profiteert van het feit dat de meeste commandos de waarden niet uit de stapel halen.
Als het scheidingsteken wordt genegeerd, kan dit worden gedaan met 5 bytes .O+!)

Brainfuck, 16,15, 14/13 tekens

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

Genereert de Fibonacci-reeks en drukt niets af. Is ook korter dan de bovenstaande.

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

Dit men heeft 14 tekens maar drukt ASCII-tekens af met de waarden van de Fibonacci-reeks.

Opmerkingen

• Dit is goed, maar zou ik onjuist zijn door te zeggen dat de 14-byte-versie alleen uitvoer vanaf de 2e 1? Zoals in " 1 2 3 5 8 " in plaats van " 1 1 2 3 5 8 "?
• @Charlim Oh, jij ' re right. Ik heb geen idee wat de ik van 2014 dacht. Hoe dan ook, ik heb het gewoon opgelost door mov de afdrukinstructie vooraan in de lus plaatsen.