Fibonacci-Orial

36

Definition

Die Fibonacci-Sequenz F(n)auf den positiven ganzen Zahlen ist wie folgt definiert:

1. F(1) = 1
2. F(2) = 1
3. F(n) = F(n-1) + F(n-2), where n is an integer and n > 2

Das Fibonacci-Orial einer positiven ganzen Zahl ist das Produkt von [F(1), F(2), ..., F(n)].

Aufgabe

Bei positiver Ganzzahl nfinden Sie das Fibonacci-Orial von n.

Technische Daten

Die Fibonacci-Zeitmessung von 100muss auf einem vernünftigen Computer in weniger als 5 Sekunden berechnet werden.

Testfälle

n   Fibonacci-orial of n
1   1
2   1
3   2
4   6
5   30
6   240
7   3120
8   65520
9   2227680
10  122522400
11  10904493600
12  1570247078400
13  365867569267200
14  137932073613734400
15  84138564904377984000
16  83044763560621070208000
17  132622487406311849122176000
18  342696507457909818131702784000
19  1432814097681520949608649339904000
20  9692987370815489224102512784450560000
100 3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000

Verweise

code-golf  math  sequence  arithmetic  fibonacci 
— Undichte Nonne
quelle
— Undichte Nonne
1
@ LuisMendo Die Summe der Fibonacci ist ... Sie haben es erraten, Fibonacci. Nun, minus eins.
— Undichte Nonne
2
@LeakyNun Derzeit werden mit der JavaScript-Antwort nur die Testfälle bis zu 15 abgeschlossen, da JavaScript Zahlen über 2 ^ 53 - 1 nicht korrekt vergleichen (oder manipulieren) kann. Dies ist höchstwahrscheinlich bei vielen Einsendungen hier ähnlich, da die meisten Sprachen dies nicht tun Unterstützung Zahlen, die groß
— MayorMonty
1
Was meinst du mit "vernünftigen Computer"?
— Erik der Outgolfer
2
-1, weil dies wie mehrere Herausforderungen aussieht (Bereich, Fibonacci von jeder, Fakultät), ohne besonders interessante Abkürzungen.
— Esolanging Fruit

Antworten:

63

Mathematica, 10 Bytes

Fibonorial

Ein weiteres Mathematica-System, das von einer Golfsprache ohne das eingebaute System geschlagen wird.

— Martin Ender
quelle
49
Ich ... w-was ... warum, Mathematica ?!
— Lynn
3
Habe vergessen, dass es diese Funktion überhaupt gibt!
— LegionMammal978
3
@Lynn Regel 35 : Wenn es existiert, gibt es eine Mathematica-Funktion;)
— Beta Decay
9
@BetaDecay Ich dachte, wir hätten festgestellt, dass es sich um Artikel 110 handelt .
— Martin Ender
1
Nein, Regel 110 ist etwas ganz anderes. Ich bin mir allerdings sicher, dass Mathematica auch dafür eine integrierte Lösung hat.
— AdmBorkBork
27

Gelee , 6 Bytes

+С1ḊP

Die Eingabe 100 wird in 500 ms lokal beendet. Probieren Sie es online!

Wie es funktioniert

+С1ḊP  Niladic link. No input.
        Since the link doesn't start with a nilad, the argument 0 is used.

   1    Yield 1.
+       Add the left and right argument.
 С     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.
        Collect all values of the left argument into an array.
    Ḋ   Dequeue; discard the first Fibonacci number (0).
     P  Product; multiply the remaining ones.
— Dennis
quelle
Ist also +¡1ein nicht in n gebautes Fibonacci und +С1sind die ersten n Fibonacci-Zahlen?
— Caird Coinheringaahing
@cairdcoinheringaahing Ziemlich viel.
— Dennis
Ich dachte, es gibt eine eingebaute Fibonacci-Funktion?
— MilkyWay90
21

Eigentlich 4 Bytes

Führt die Eingabe 100 innerhalb von 0,2 Sekunden aus. Code:

R♂Fπ

Erläuterung:

R     # Get the range [1, ..., input].
 ♂F   # Map over the array with the fibonacci command.
   π  # Take the product.

Verwendet die CP-437- Codierung. Probieren Sie es online! .

— Adnan
quelle
1
Dies ist das richtige Werkzeug für den Job :) Dank einiger Verbesserungen an der Fibonacci-Funktion, die Leaky Nun vor einiger Zeit vorgenommen hat, läuft der 100-Testfall mit TIO in 0,1 Sekunden .
— Mego
16

Brainfuck, 1198 1067 817 770 741 657 611 603

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

Unkomprimiert mit Kommentaren:

# parse input (max 255)
,[>++++++[-<-------->]<<[->++++++++++<]>>,]
>+>+>>+>+<<<<<<
[->>>
  # compute next fibonacci number
  [[-]<
    [->+<]>>
    [-<+<+>>]<
    # perform carries
    [->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<
      [->[-]>>>>>>+>+<<<<<<<<[->+<]]
    ]]]]]]]]]+>>>>>>>>
  ]<<<<<<<<
  # multiplication
  [->
    # extract next digit of F_n (most significant first)
    [-<+<<+>>>]<
    [->+<]>>>
    # move back to the end
    [<<<<<
      [->>>>>>>>+<<<<<<<<]>>>>>>>>>>>>>
    ]<<<<<<<<
    # digit wise multiplication (shifting current digit)
    [->>>
      [-<<<<<<<<+>>>>
        [->+>>+<<<]>
        [-<+>]>>>
      ]<<
      # shift previous total over one gap (in effect multiplying by 10)
      [->>>>>>>+>+<<<<<<<<]<+<<<<<<<<
    ]>>>[-]>>>>>
    # add product to total
    [[-]>
      [->+<]>
      # perform carries
      [-<+>
        [-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>
          [->>>>>>+>+<<<<<<<<[-]]
        ]]]]]]]]>
      ]<<[<]+>>>>>>>>
    ]<<<<<<<<
    [<<<<<<<<]>>>>>
    [>>>>>>>>]+<<<<<<<<
  ]>>>>>>>>>>>
  # overwrite previous product
  [<[-]>>
    [-<<+>>]>>>>>>>
  ]<<<<<<<<
  [<<<<<<<<]>>
]>>>>>>
# output product
[>>>>>>>>]<<<<<<<<
[+++++
  [-<++++++++>]<.<<<<<<<
]

Probieren Sie es online!

Die Laufzeit für n = 100 ist mit dem Online-Interpreter kürzer als 1 Sekunde (ca. 0,2s lokal mit meinem eigenen Interpreter). Die maximale Eingabe beträgt 255, der Interpreter muss jedoch ~ 54000 Zellen unterstützen (der Online-Interpreter scheint 64 KB zu verarbeiten).

Änderungsprotokoll

Es wurden ca. 130 Bytes gespeichert, wobei die aktuelle Ziffer besser extrahiert und durch Zusammenführen von Addieren und Übertragen in einem Durchgang multipliziert werden konnte. Es scheint auch ein bisschen schneller zu sein.

Weitere 250 Bytes gespeichert. Ich habe es geschafft, meinen Multiplikations-Notizblock um zwei Zellen zu verkleinern, wodurch fast überall Bytes gespart werden, da ich nicht so weit zwischen den Ziffern wechseln muss. Ich habe auch den Übertrag nach dem Multiplizieren mit einer Ziffer verworfen und stattdessen einen vollständigen Übertrag ausgeführt, während ich die laufende Summe addiere.

Hieb weitere 50 ab, wieder mit besserer Extraktion der aktuellen Ziffer zum Multiplizieren mit, indem man sie einfach die erste Iteration nicht vorwärts bewegt und von dort aus arbeitet, wo sie ist. Ein paar Mikrooptimierungen weiter unten machen ungefähr 10 Bytes aus.

30 weitere sind weg. Das Markieren von Ziffern, die bereits mit einer 0 statt einer 1 belegt wurden, erleichtert das Auffinden. Außerdem wird die Prüfung, ob die Multiplikationsschleife beendet ist, einfacher.

Ich habe den Notizblock um eine weitere Zelle verkleinert, um weitere 80 Byte. Ich habe dazu den Marker für das vorherige Produkt und die aktuelle laufende Summe zusammengeführt, was die Verschiebungen zwischen den Lücken verringert und die Buchhaltung ein wenig erleichtert.

Sparte weitere 50, indem du eine weitere Zelle eliminierst und den Marker für die Fibonacci-Ziffern wieder verwendest, um auch die zuletzt aufgenommene Ziffer zu markieren. Ich konnte auch die Schleife zusammenführen, um die vorherigen Summen mit der ziffernweisen Multiplikationsschleife zu verschieben.

8 Bytes beim Parsing der Eingabe gespeichert. Hoppla.

— primo
quelle
14

Python, 45 Bytes

a=b=o=1
exec"o*=a;a,b=b,a+b;"*input()
print o

Die Eingabe erfolgt aus stdin. Die Ausgabe für n = 100 wird zu schnell beendet, um eine genaue Zeitangabe zu erhalten. n = 1000 dauert ungefähr 1s.

Beispielnutzung

$ echo 10 | python fib-orial.py
122522400

$ echo 100 | python fib-orial.py
3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000
— primo
quelle
13

Haskell 41 29 Bytes

1 + 11 Bytes, die durch @ Laikonis Bemerkungen gespeichert wurden.

f=1:scanl(+)1f
(scanl(*)1f!!)

1, fUnd !!sind separate Token. Die erste Zeile definiert die Fibonacci-Sequenz, die zweite ist eine Funktion, die die Sequenz der Fibonacci-Orials berechnet und das n-te für ein gegebenes n zurückgibt. Es wird fast sofort mit dem Drucken von Ziffern begonnen, auch bei n = 1000.

— Christian Sievers
quelle
1
Sie können den Raum loswerden (scanl(*)1f!!).
— Laikoni
2
Und es ist ein kürzerer Fibonacci - Generator hier :f=1:scanl(+)1f
— Laikoni
@Laikoni Das ist unglaublich, danke!
— Christian Sievers
2
@ WillNess Ich glaube, ich bin nicht nur durch das, was andere Benutzer tun, gerechtfertigt, sondern auch durch meta.codegolf.stackexchange.com/questions/2419/… und meta.codegolf.stackexchange.com/questions/9031/… (aber es gibt eine viel mehr und ich habe nicht alles gelesen)
— Christian Sievers
1
@flawr Würden Sie 42+als eine Funktion akzeptieren , die 42 hinzufügt? Das solltest du nicht, denn es ist nur ein unvollendeter Ausdruck. Aber in Haskell können wir Klammern hinzufügen und den Abschnitt erhalten (42+) , eine Möglichkeit, die Funktion zu schreiben \n->42+n. Hier ist es dasselbe, nur mit !!(dem binären Infix-Operator für die Indizierung) +und einem komplizierteren ersten Operanden.
— Christian Sievers
11

Python 2, 39 Bytes

f=lambda n,a=1,b=1:n<1or a*f(n-1,b,a+b)

Teste es auf Ideone .

— Dennis
quelle
Möglicherweise möchten Sie angeben, dass es Truein einigen Fällen zurückgegeben wird.
— Undichte Nonne
5
Dies würde nur Truefür den Eingang 0 zurückkehren , was nicht positiv ist.
— Dennis
6

J, 17 16 Bytes

1 Byte ist meilenweit mit einer noch besseren Lösung golfen.

[:*/+/@(!|.)\@i.

Die Idee ist die gleiche wie im Original, aber anstatt die Matrix für kleine Diagonalen zu bilden, bilden wir die Diagonalen im laufenden Betrieb.

Original

So erhalten Sie die ersten n Fibonomials:

*/\(#{.+//.)!/~i.

Lesen von rechts nach links ...
Erstellen Sie das Array von aufeinanderfolgenden ganzen Zahlen ( i.) bis zu einer bestimmten Zahl. Erstellen Sie aus diesem Array die Tabelle ( /~) der Binomialkoeffizienten ( !), die aus jedem Paar im Array berechnet wird das ende der ersten reihe und alle elemente unter der hauptdiagonale sind 0, danke für die umsetzung von !. Wenn Sie +/alle kleinen Diagonalen ( /.) summieren , erhalten Sie Fibonacci-Zahlen, aber Sie müssen {.so viele erste Elemente aus dem resultierenden Array nehmen wie die Länge ( #) der Tabelle selbst. Dann ergibt das Produkt ( */), das auf aufeinanderfolgende Präfixe ( \) des Arrays angewendet wird, die gewünschte Folge von Fibonorials.Wenn Sie möchten, können Sie nur das letzte mit 2 weiteren Bytes ( {:) nehmen, aber ich dachte, dass das Anzeigen aller Bytes keine Sünde ist :).
NB. the previous code block is not a J function.

   {:*/\(#{.+//.)!/~i. 10
122522400

Für große Zahlen in J verwenden Sie xam Ende:

   {:*/\(#{.+//.)!/~i. 100x
3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225...

Das Programm läuft mit durchschnittlich 0,11s .

   100 timex '{:*/\(#{.+//.)!/~i.100x'
0.112124
— Dan Oak
quelle
1
Eine Alternative, die eine Funktion ist, [:*/+/@(!|.)\@i.verwendet 16 Bytes. Es bildet dieselben Binomialkoeffizienten entlang der von Ihnen generierten Tabelle, mit der !/~Ausnahme, dass es diese bildet, indem Präfixe von verwendet werden i..
— Meilen
4

Pyth, 13 Bytes

u*Gs=[sZhZ)Q1

Demonstration

Dies setzt einen cleveren, nicht typsicheren Trick ein. Fünf der Zeichen ( u*G ... Q1) geben an, dass die Ausgabe das Produkt der Eingabe vieler Zahlen ist. Der Rest des Codes generiert die Zahlen.

=[sZhZ)Aktualisiert die Variable Zin der Liste [s(Z), h(Z)]. Dann ssummiert diese Liste, um multipliziert zu werden.

Zist anfangs 0. sints ist die Identitätsfunktion. hist die + 1Funktion. Also auf der ersten Iteration Zwird [0, 1]. sauf Listen ist die Summenfunktion, wie oben erwähnt. hist die Kopffunktion. Die zweite Iteration ist also [1, 0].

Hier ist eine Liste:

Iter  Z          Sum
0     0          Not used
1     [0, 1]     1
2     [1, 0]     1
3     [1, 1]     2
4     [2, 1]     3
5     [3, 2]     5

Diese Summen werden multipliziert, um das Ergebnis zu erhalten.

— isaacg
quelle
4

Mathematica 25 24 Bytes

Mit Dank an Martin Ender.

1##&@@Fibonacci@Range@#&

1##&@@Fibonacci@Range@#&@100

Timing: 63 Mikrosekunden.

{0.000063, 
3371601853146468125386964065447576689828006172937411310662486977801540
6711385898686165008341900290675836651822917015531720110825745874313823
1009903039430687777564739516714333248356092511296002464445971530050748
1235056111434293619038347456390454209587101225261757371666449068625033
9995735521655245297254676280601708866020010771376138030271586483293355
0772869860576999281875676563330531852996518618404399969665040724619325
7877568825245646129366994079739720698147440310773871269639752334356493
6789134243905645353892122400388956268116279491329780860702550826683922
9003714114129148483959669418215206272639036409444764264391237153249138
8089634845995941928089653751672688740718152064107169357399466473375804
9722605947689699525073466941890502338235963164675705844341280523988912
2373033501909297493561702963891935828612435071136036127915741683742890
4150054292406756317837582840596331363581207781793070936765786629772999
8328572573496960944166162599743042087569978353607028409125185326833249
36435856348020736000000000000000000000000}
— DavidC
quelle
Alternativ mit der gleichen Byteanzahl:1##&@@Fibonacci~Array~#&
— Greg Martin
4

Gelee, 8 Bytes

RḶUc$S€P

Meine erste Einreichung in Jelly. Es ist nicht so kurz wie die Antwort von @Dennis , aber mit einer anderen Methode nur 2 Byte länger.

Vor Ort sind etwa 400 ms erforderlich, verglichen mit 380 ms bei der @ Tennis-Version für n = 100.

Probieren Sie es online!

Erläuterung

RḶUc$S€P  Input: n
R         Generate the range [1, 2, ..., n]
          For each value x in that range
 Ḷ          Create another range [0, 1, ..., x-1]
  U         Reverse that list
   c        Compute the binomial coefficients between each pair of values
    $       Bind the last two links (Uc) as a monad
     S€   Sum each list of binomial coefficients
          This will give the first n Fibonacci numbers
       P  Take the product of those to compute the nth Fibonacci-orial
— Meilen
quelle
3

PARI / GP, 29 Bytes

f=n->prod(i=1,n,fibonacci(i))

Oder alternativ:

f=n->prod(i=a=!b=0,n,b=a+a=b)
— primo
quelle
3

R 99 96 78 76 66 Bytes

Diese Antwort verwendet die Binet-Formel sowie die prod(x)Funktion. Da R keinen eingebauten PhiWert hat, habe ich es selbst definiert:

p=(1+sqrt(5))/2;x=1;for(n in 1:scan())x=x*(p^n-(-1/p)^n)/sqrt(5);x

Es funktioniert unter 5 Sekunden, aber R neigt dazu zu gebenInf als Antwort auf diese großen Zahlen zu geben ...

Ungolfed:

r=sqrt(5)
p=(1+r)/2 
x=1
for(n in 1:scan())        
    x=x*(p^n-(-1/p)^n)/r    
x

-2 Bytes dank @Cyoce!
Oh, liebe ich diese Seite? -10 Bytes dank @ user5957401

— Frédéric
quelle
sqrt(5)
— Könnte
da Sie nur Neinmal verwenden, können Sie nur Scan innerhalb des 1:NBits aufrufen . dh for(n in 1:scan()). Sie können auch einige Zeichen speichern, indem Sie *anstelle der prod()Funktion in Ihrer for-Schleife verwenden. Ihre for-Schleife besteht nur aus einer Zeile, daher benötigen Sie auch keine geschweiften Klammern.
— user5957401
Gute Idee, die Binet-Formel zu verwenden. In deinem Geiste sind es aber nur 53 Bytesfunction(n,N=1:n,p=5^.5)prod(((1+p)^N-(1-p)^N)/2^N/p)
— Michael M
3

R, 82 , 53 , 49 Bytes (48 Bytes mit unterschiedlichem Eingabestil)

b=d=1;a=0;for(i in 1:scan()){d=d*b;b=a+b;a=b-a};d

Wenn wir dem Code nur die eingegebene Nummer voranstellen können, erhalten wir die 48 Byte

->n;b=d=1;a=0;for(i in 1:n){d=d*b;b=a+b;a=b-a};d

EDIT: Neuer Code. Original ist unten:

a=function(n)ifelse(n<3,1,{v=c(1,1,3:n);for(i in 3:n)v[i]=v[i-1]+v[i-2];prod(v)})

Gibt nichts anderes als Inf für zurück a(100) . Und es funktioniert nur für nicht negative ganze Zahlen.

Ungolfed:

a=function(n){
   if(n<3) return(1)
   v=c(1,1,3:n)
   for(i in 3:n)
       v[i]=v[i-1]+v[i-2]
   prod(v)
}
— user5957401
quelle
3

Java, 165 Bytes

Golf gespielt:

BigInteger f(int n){BigInteger[]a={BigInteger.ZERO,BigInteger.ONE,BigInteger.ONE};for(int i=0;i<n;){a[++i%2]=a[0].add(a[1]);a[2]=a[2].multiply(a[i%2]);}return a[2];}

Dies ist ein weiterer Fall, bei BigIntegerdem aufgrund der großen Anzahl Bedarf besteht. Es gelang mir jedoch, den Text BigIntegerauf ein Minimum zu beschränken und die Größe gering zu halten. Ich habe es auch mit statischen Importen verglichen und es hat die Gesamtlänge verlängert.

Dieses Programm verfolgt drei Zahlen in einem Array. Die ersten beiden sind die vorherigen beiden Fibonacci-Zahlen. Der dritte ist der akkumulierte Wert. Die Schleife beginnt damit, dass der nächste Wert berechnet und in abwechselnden (0, 1, 0, 1, ...) Array-Indizes gespeichert wird. Dies vermeidet, dass Werte mit kostspieligen (in Bezug auf die Quellgröße) Zuweisungsoperationen verschoben werden müssen. Nehmen Sie dann diesen neuen Wert und multiplizieren Sie ihn mit dem Akku.

Durch die Vermeidung temporärer Objekte und die Beschränkung der Schleife auf zwei Zuweisungsoperatoren konnte ich einige Bytes herauspressen.

Ungolfed:

import java.math.BigInteger;

public class Fibonacci_orial {

  public static void main(String[] args) {
    // @formatter:off
    String[][] testData = new String[][] {
      { "1", "1" },
      { "2", "1" },
      { "3", "2" },
      { "4", "6" },
      { "5", "30" },
      { "6", "240" },
      { "7", "3120" },
      { "8", "65520" },
      { "9", "2227680" },
      { "10", "122522400" },
      { "11", "10904493600" },
      { "12", "1570247078400" },
      { "13", "365867569267200" },
      { "14", "137932073613734400" },
      { "15", "84138564904377984000" },
      { "16", "83044763560621070208000" },
      { "17", "132622487406311849122176000" },
      { "18", "342696507457909818131702784000" },
      { "19", "1432814097681520949608649339904000" },
      { "20", "9692987370815489224102512784450560000" },
      { "100", "3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000" }
    };
    // @formatter:on

    for (String[] data : testData) {
      System.out.println("Input: " + data[0]);
      System.out.println("Expected: " + data[1]);
      System.out.print("Actual:   ");
      System.out.println(new Fibonacci_orial().f(Integer.parseInt(data[0])));
      System.out.println();
    }
  }

  // Begin golf
  BigInteger f(int n) {
    BigInteger[] a = { BigInteger.ZERO, BigInteger.ONE, BigInteger.ONE };
    for (int i = 0; i < n;) {
      a[++i % 2] = a[0].add(a[1]);
      a[2] = a[2].multiply(a[i % 2]);
    }
    return a[2];
  }
  // End golf

}

Programmausgabe:

Input: 1
Expected: 1
Actual:   1

Input: 2
Expected: 1
Actual:   1

Input: 3
Expected: 2
Actual:   2

Input: 4
Expected: 6
Actual:   6

Input: 5
Expected: 30
Actual:   30

Input: 6
Expected: 240
Actual:   240

Input: 7
Expected: 3120
Actual:   3120

Input: 8
Expected: 65520
Actual:   65520

Input: 9
Expected: 2227680
Actual:   2227680

Input: 10
Expected: 122522400
Actual:   122522400

Input: 11
Expected: 10904493600
Actual:   10904493600

Input: 12
Expected: 1570247078400
Actual:   1570247078400

Input: 13
Expected: 365867569267200
Actual:   365867569267200

Input: 14
Expected: 137932073613734400
Actual:   137932073613734400

Input: 15
Expected: 84138564904377984000
Actual:   84138564904377984000

Input: 16
Expected: 83044763560621070208000
Actual:   83044763560621070208000

Input: 17
Expected: 132622487406311849122176000
Actual:   132622487406311849122176000

Input: 18
Expected: 342696507457909818131702784000
Actual:   342696507457909818131702784000

Input: 19
Expected: 1432814097681520949608649339904000
Actual:   1432814097681520949608649339904000

Input: 20
Expected: 9692987370815489224102512784450560000
Actual:   9692987370815489224102512784450560000

Input: 100
Expected: 3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000
Actual:   3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000
2

Ruby, 39 Bytes

->n{f=i=b=1;n.times{f,i,b=i,f+i,b*f};b}
— Lynn
quelle
36: -> n {f = i = b = 1; n × {b * = f; i = f + f = i}; b}
— GB
2

Javascript (ES6), 51 39 Bytes

Rekursive Implementierung (39 Bytes)

f=(n,a=p=i=b=1)=>++i<n?f(n,b,p*=b+=a):p

Ursprüngliche Implementierung (51 Byte)

n=>{for(i=a=b=p=1;++i<n;){c=a;a=b;p*=b+=c}return p}

Hinweis: Startet Rundungsfehler für das Fibonacci-Orial von 16, 100 ist nur Unendlich, läuft in scheinbar <1 Sekunde.

— Pandacoder
quelle
Ich habe eine alternative 53-Byte-Version erstellt, n=>[...Array(n)].reduce(p=>(c=a,a=b,p*=b+=c),a=1,b=0)nur um festzustellen, dass Sie die gezählt haben, f=die Sie nicht benötigen, um 2 Byte zu sparen.
— Neil
Gutes Argument. Mein Grundgedanke war, dass es aufrufbar und wiederverwendbar war und nicht nur aufrufbar.
— Pandacoder
Sicher, aber wenn jemand es wiederverwenden möchte, hat er immer noch die Möglichkeit, es zu benennen.
— Neil
@Neil Nun, ich habe es reimplementiert und jetzt ist das f = obligatorisch, sonst kann es nicht ausgeführt werden. : D
— Pandacoder
Nun, zumindest haben Sie die Byteanzahl für die ursprüngliche Implementierung festgelegt.
— Neil
2

DC (GNU- oder OpenBSD-Variante) , 36 Bytes

Datei A003266-v2.dc:

0sA1sB1?[1-d0<LrlBdlA+sBdsA*r]dsLxrp

(kein abschließender Zeilenumbruch)

... jetzt wird das Ergebnis auf dem Stack gehalten, anstatt ein benanntes Register zu verwenden (ist Yin Version 1). Der rBefehl ist im Original nicht verfügbar dc(siehe RosettaCodes Dc-Seite ).

Lauf:

$ time dc -f A003266-v2.dc <<< 100
337160185314646812538696406544757668982800617293741131066248697780154\
067113858986861650083419002906758366518229170155317201108257458743138\
231009903039430687777564739516714333248356092511296002464445971530050\
748123505611143429361903834745639045420958710122526175737166644906862\
503399957355216552452972546762806017088660200107713761380302715864832\
933550772869860576999281875676563330531852996518618404399969665040724\
619325787756882524564612936699407973972069814744031077387126963975233\
435649367891342439056453538921224003889562681162794913297808607025508\
266839229003714114129148483959669418215206272639036409444764264391237\
153249138808963484599594192808965375167268874071815206410716935739946\
647337580497226059476896995250734669418905023382359631646757058443412\
805239889122373033501909297493561702963891935828612435071136036127915\
741683742890415005429240675631783758284059633136358120778179307093676\
578662977299983285725734969609441661625997430420875699783536070284091\
2518532683324936435856348020736000000000000000000000000

real    0m0.005s
user    0m0.004s
sys     0m0.000s

Ich versuche zu erklären:

tosist der Inhalt der Oberseite des Stapels, ohne ihn zu entfernen.
nosist das Element unten tos.

0 sA # push(0) ; A=pop()
1 sB # push(1) ; B=pop()
1    # push(1)
     # this stack position will incrementally hold the product
?    # push( get user input and evaluate it )
[    # start string
 1-  # push(pop()-1)
 d   # push(tos)
 0   # push(0)
 <L  # if pop() < pop() then evaluate contents of register L
 r   # exchange tos and nos
     # now nos is the loop counter
     # and tos is the bucket for the product of the fibonacci numbers
 lB  # push(B)
 d   # push(tos)
 lA  # push(A)
 +   # push(pop()+pop())
     # now tos is A+B, nos still is B 
 sB  # B=pop()
     # completes B=A+B
 d   # push(tos)
 sA  # A=pop()
     # completes B=A
     # tos (duplicated new A from above) is the next fibonacci number
 *   # push(nos*tos)
     # tos now is the product of all fibonacci numbers calculated so far
 r   # exchange tos and nos
     # now tos is the loop counter, nos is the product bucket
]    # end string and push it
d    # push(tos)
sL   # L=pop()
x    # evaluate(pop())
r    # exchange tos and nos
     # nos now is the former loop counter
     # tos now is the complete product. \o/
p    # print(tos)
     # this does not pop() but who cares? :-P

DC , 41 Bytes

... geradeaus, keine Tricks:

Datei A003266-v1.dc:

0sA1sB1sY?[1-d0<LlBdlA+sBdsAlY*sY]dsLxlYp

(kein abschließender Zeilenumbruch)

Lauf:

$ for i in $(seq 4) ; do dc -f A003266-v1.dc <<< $i ; done
1
1
2
6
$ time dc -f A003266-v1.dc <<< 100
337160185314646812538696406544757668982800617293741131066248697780154\
067113858986861650083419002906758366518229170155317201108257458743138\
231009903039430687777564739516714333248356092511296002464445971530050\
748123505611143429361903834745639045420958710122526175737166644906862\
503399957355216552452972546762806017088660200107713761380302715864832\
933550772869860576999281875676563330531852996518618404399969665040724\
619325787756882524564612936699407973972069814744031077387126963975233\
435649367891342439056453538921224003889562681162794913297808607025508\
266839229003714114129148483959669418215206272639036409444764264391237\
153249138808963484599594192808965375167268874071815206410716935739946\
647337580497226059476896995250734669418905023382359631646757058443412\
805239889122373033501909297493561702963891935828612435071136036127915\
741683742890415005429240675631783758284059633136358120778179307093676\
578662977299983285725734969609441661625997430420875699783536070284091\
2518532683324936435856348020736000000000000000000000000

real    0m0.006s
user    0m0.004s
sys     0m0.004s
1
* seufz! * ... dcCode zu schreiben ist definitiv einfacher als es zu erklären ...
1
Ja, wir brauchen wirklich eine IDE mit einem verrückten Visualisierungs-Gadget für mehrere Stapel ... das wäre süß.
— Joe
1
Ich habe mehrere Ideen, was als neue Befehle hinzugefügt werden soll, aber die Idee mit der größten Auswirkung scheint zu sein: Hinzufügen eines Befehls "Standardstapel ändern". ;-)
2
... oder tauschen Sie den Standardstapel mit einem benannten Register aus. Das würde mehr Knoten in den Gehirnen der Benutzer machen, würde aber nicht den Standardstapel benötigen, um einen Namen zu haben ...] :-)
1
Ja, das wäre auf jeden Fall praktisch! Ich möchte auch ein einzelnes Element löschen, Elemente drehen, die sich nicht oben auf dem Stapel befinden, und die obersten nElemente möglicherweise sofort auf einen anderen Stapel verschieben. Derzeit weiß ich jedoch noch nicht, wie ich dcaus dem Quellcode kompilieren soll . : /
— Joe
2

C # 110 109 107 103 101 94 Bytes

using i=System.Numerics.BigInteger;i f(i n){i a=0,b=1,x=1;for(;n-->0;)x*=a=(b+=a)-a;return x;}

Erläuterung

//Aliasing BigInteger saves a few bytes
using i=System.Numerics.BigInteger;

//Since BigInteger has an implicit from int we can also change the input
//and save two more bytes.
i f(i n)
{
    //using an alternative iterative algorithm (link to source below) to cut out the temp variable
    //b is next iteration, a is current iteration, and x is the running product
    i a = 0, b = 1, x = 1; 

    //post decrement n down to zero instead of creating a loop variable
    for (; n-- > 0;)

        //The bracket portion sets the next iteration             
        //get the current iteration and update our running product
        x *= a = (b += a) - a;

    return x;
}

Iterativer Fib-Algorithmus

— JustinM - Setzen Sie Monica wieder ein
quelle
Da dies so viel besser lief, als ich erwartet hatte, wollte ich das maximale N finden, das in weniger als 5 Sekunden zurückkehren würde. Ich kam mit 1540 heraus, was eine Zahl ergibt, die 247441 Ziffern lang ist.
— JustinM
Beeindruckend. Wie lange dauert es aus Neugier, bis 1541 berechnet ist?
— Pandacoder
@Pandacoder Mit der letzten Änderung des Algorithmus ist es also deutlich schneller geworden. 1541 in 755 ms also werde ich jetzt die neue sub 5 max finden.
— JustinM Reinstate Monica
@Pandacoder also die Laufzeit variiert um ein gutes Stückchen ~ 100ms, aber 2565 scheint im Durchschnitt ungefähr 5 Sekunden zu sein
— JustinM - Reinstate Monica
Wie lang ist die Nummer dafür?
— Pandacoder
2

Brain-Flak , 54 Bytes

([{}]<(())>){(({})()<{({}()<([({})]({}{}))>)}{}{}>)}{}

Probieren Sie es online!

Die Multiplikation in Brain-Flak benötigt für große Eingaben viel Zeit. Allein die Multiplikation von F 100 mit F 99 mit einem generischen Multiplikationsalgorithmus würde Milliarden von Jahren dauern.

Zum Glück gibt es einen schnelleren Weg. Eine verallgemeinerte Fibonacci-Sequenz, die mit beginnt (k, 0), erzeugt dieselben Terme wie die übliche Sequenz, multipliziert mit k. Mit dieser Beobachtung kann Brain-Flak genauso einfach mit einer Fibonacci-Zahl multiplizieren, wie es Fibonacci-Zahlen erzeugen kann.

Wenn der Stapel aus -nzwei {({}()<([({})]({}{}))>)}{}{}aufeinanderfolgenden Zahlen besteht, werden nIterationen der verallgemeinerten Fibonacci-Sequenz berechnet und alle bis zum letzten verworfen. Der Rest des Programms richtet nur die anfängliche 1 ein und durchläuft diese für alle Zahlen im Bereich n...1.

Hier ist der gleiche Algorithmus in den anderen Sprachen, die von diesem Interpreter bereitgestellt werden:

Brain-Flak Classic, 52 Bytes

({}<(())>){(({})[]<{({}[]<(({}<>)<>{}<>)>)}{}{}>)}{}

Probieren Sie es online!

Brain-Flueue, 58 Bytes

<>(<(())>)<>{(({}<>)<{({}({}))({}[()])}{}>[()]<>)}<>({}){}

Probieren Sie es online!

Mini-Flak, 62 Bytes

([{}()](())){(({})()({({}()([({})]({}{}))[({})])}{}{})[{}])}{}

Probieren Sie es online!

— Nitrodon
quelle
1

Mathematica - 32 26 Bytes

Fibonacci@i~Product~{i,#}&

@MartinEnder 6 Bytes gehackt!

— Yytsi
quelle
1

Rubin, 85 Bytes

g =->x{(1..x).to_a.collect{|y|(0..y).inject([1,0]){|(a,b),_|[b, a+b]}[0]}.inject(:*)}

Hat sich als gut herausgestellt, aber es gibt wahrscheinlich eine kürzere Lösung.

Schnelle Fibonnaci-Berechnung von hier: Link

Teste es hier

— Seims
quelle
1

Julia, 36 Bytes

!x=[([1 1;1 0]^n)[2]for n=1:x]|>prod
— Lynn
quelle
1

Brain-Flak , 110 104 100 Bytes

Probieren Sie es online!

({}<((())<>)>){({}[()]<<>(({})<>({}<>)<>)>)}<>{}([[]]()){({}()<({}<>)<>({<({}[()])><>({})<>}{})>)}{}

Erläuterung

Zuerst führen wir eine verbesserte Version des Fibonacci-Sequenzgenerators von Dr. Green Eggs und Iron Man aus

({}<((())<>)>){({}[()]<<>(({})<>({}<>)<>)>)}<>{}

Dann, während der Stapel mehr als einen Gegenstand hat

([[]]()){({}()<...>)}

Multipliziere die beiden obersten Punkte

({}<>)<>({<({}[()])><>({})<>}{})

und die zusätzliche Null platzen lassen

{}
— Weizen-Assistent
quelle
1
Leider halte ich dies für ungültig, da die Eingabe von 25 mehr als 10 Sekunden dauert. Der Algorithmus ist sehr ineffizient (genau wie die Sprache), sodass die Berechnung für 100 wahrscheinlich Stunden dauern würde.
— DJMcMayhem
1

Clojure, 70 Bytes

Clojure ist keine gute Sprache für Code-Golf. Naja.

Probieren Sie es unter http://tryclj.com .

(last(nth(iterate(fn[[a b r]][b(+ a b)(* r(+ a b))])[0N 1 1])(dec n)))
— user16973
quelle
1

Schnell, 68 Bytes

func f(n:Int,_ a:Int=1,_ b:Int=1)->Int{return n<1 ?1:a*f(n-1,b,a+b)}
— Alexander
quelle
1

JavaScript (ES6), 46 Byte

f=(n,a=1,b=1,c=i=1)=>n==i?c:f(n,b,a+b,c*b,++i)

Verwendet Rekursions- und Akkumulatorvariablen. Rundungsfehler beginnen bei f(16).

— cPu1
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.