Fibonacci-ORIAL

36

Definizione

La sequenza di Fibonacci F(n), sugli interi positivi, è definita come tale:

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

Il Fibonacci-oriale di un numero intero positivo è il prodotto di [F(1), F(2), ..., F(n)].

Compito

Dato un numero intero positivo n, trova il Fibonacci-oriale di n.

Specifiche

Il fibonacci-oriale di 100deve calcolare in meno di 5 secondi su un computer ragionevole.

Casi test

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

Riferimenti

code-golf  math  sequence  arithmetic  fibonacci 
— Perdente Suora
fonte
— Leaky Nun,
1
@LuisMendo La somma dei fibonacci è ... l'hai indovinato, fibonacci. Bene, meno uno.
— Leaky Nun,
2
@LeakyNun Attualmente la risposta JavaScript completa solo i casi di test fino a 15 perché JavaScript non può confrontare correttamente (o manipolare) numeri oltre 2 ^ 53 - 1. Questo è molto probabilmente simile per molti degli invii qui, perché la maggior parte delle lingue non lo fanno numeri di supporto così grandi
— MayorMonty
1
Cosa intendi con "computer ragionevole"?
— Erik the Outgolfer,
2
-1 perché questa sembra una serie di sfide affrontate insieme (range, fibonacci di ciascuna, fattoriale) senza scorciatoie particolarmente interessanti.
— Esolanging Fruit il

Risposte:

63

Mathematica, 10 byte

Fibonorial

Un altro Mathematica integrato è battuto in modo armonioso da un linguaggio del golf senza il built-in.

— Martin Ender
fonte
49
Io ... w-cosa ... perché, Mathematica ?!
— Lynn,
3
Ho dimenticato che esisteva anche quella funzione!
— LegionMammal978,
3
@Lynn Regola 35 : se esiste, c'è una sua funzione Mathematica;)
— Decadimento beta
9
@BetaDecay Pensavo che avessimo stabilito che si tratta della regola 110 .
— Martin Ender,
1
No, la regola 110 è qualcosa di molto diverso. Anche se sono sicuro che anche Mathematica ha un built-in per questo.
— AdmBorkBork,
27

Gelatina , 6 byte

+С1ḊP

L'ingresso 100 termina in locale a 500 ms. Provalo online!

Come funziona

+С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
fonte
Quindi +¡1un n-fibonacci non è costruito ed +С1è il primo n numeri di Fibonacci?
— caird coinheringaahing l'
@cairdcoinheringaahing Praticamente.
— Dennis,
Pensavo ci fosse una funzione fibonacci integrata?
— MilkyWay90
16

Brainfuck, 1198 1067 817 770 741 657 611 603

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

Non compresso, con commenti:

# 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
[>>>>>>>>]<<<<<<<<
[+++++
  [-<++++++++>]<.<<<<<<<
]

Provalo online!

Il tempo di esecuzione per n = 100 è inferiore a 1 secondo con l'interprete online (circa 0,2 secondi a livello locale usando il mio interprete). L'input massimo è 255, ma richiederebbe all'interprete di supportare ~ 54000 celle (l'interprete online sembra concludere su 64k).

Registro delle modifiche

Risparmio di circa 130 byte con una migliore estrazione della cifra corrente da moltiplicare per, e unendo add e carry in un unico passaggio. Sembra anche essere un po 'più veloce.

Salvati altri 250 byte. Sono riuscito a ridurre il mio blocco appunti di moltiplicazione di due celle, il che consente di risparmiare byte praticamente ovunque senza dover spostare così lontano tra le cifre. Ho anche lasciato cadere il carry dopo aver moltiplicato per una cifra, e invece eseguivo un carry completo aggiungendo al totale corrente.

Ne ho tagliati altri 50, sempre con una migliore estrazione della cifra corrente da moltiplicare, semplicemente non spostandola in avanti alla prima iterazione e lavorando da dove si trova. Qualche ulteriore micro-ottimizzazione rappresenta circa ~ 10 byte.

Altri 30 andati. Contrassegnare le cifre che sono già state prese con uno 0 anziché uno 1 li rende più facili da individuare. Inoltre verifica se il ciclo di moltiplicazione è terminato in qualche modo più semplice.

Ho ridotto il blocco appunti di un'altra cella, per altri 80 byte. L'ho fatto unendo il marcatore per il prodotto precedente e l'attuale totale corrente, che riduce gli spostamenti tra gli spazi vuoti e rende un po 'più semplice la contabilità.

Ne ho salvati altri 50, eliminando ancora un'altra cella, riutilizzando il marker per le cifre dei fibonacci per contrassegnare anche l'ultima cifra presa. Sono stato anche in grado di unire il ciclo per spostare i totali precedenti con il ciclo di moltiplicazione a livello di cifre.

Salvataggio di 8 byte durante l'analisi dell'ingresso. Ops.

— Primo
fonte
14

Python, 45 byte

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

L'input è preso dallo stdin. L'output per n = 100 termina troppo rapidamente per un tempo preciso. n = 1000 richiede circa 1 s .

Esempio di utilizzo

$ echo 10 | python fib-orial.py
122522400

$ echo 100 | python fib-orial.py
3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000
— Primo
fonte
13

Haskell 41 29 byte

1 + 11 byte salvati dalle osservazioni di @ Laikoni.

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

1, fE !!sono i token separati. Le prime righe definiscono la sequenza dei fibonacci, la seconda è una funzione che calcola la sequenza dei fibonacci-oriali e restituisce l'n-esimo per un dato n. Inizia a stampare cifre quasi immediatamente anche per n = 1000.

— Christian Sievers
fonte
1
Puoi liberarti dello spazio (scanl(*)1f!!).
— Laikoni,
2
E c'è un generatore di Fibonacci più corta qui :f=1:scanl(+)1f
— Laikoni
@Laikoni È fantastico, grazie!
— Christian Sievers,
2
@WillNess Penso di non essere giustificato solo da ciò che fanno gli altri utenti, ma anche da meta.codegolf.stackexchange.com/questions/2419/… e meta.codegolf.stackexchange.com/questions/9031/… (ma esiste un molto di più e non ho letto tutto)
— Christian Sievers
1
@flawr Accetteresti 42+come una funzione che aggiunge 42? Non dovresti, perché è solo un'espressione incompiuta. Ma in Haskell possiamo aggiungere parentesi e ottenere la sezione (42+) , un modo per scrivere la funzione \n->42+n. Qui è lo stesso, solo con !!(l'operatore binario infix per l'indicizzazione) invece di +e un primo operando più complicato.
— Christian Sievers,
11

Python 2, 39 byte

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

Provalo su Ideone .

— Dennis
fonte
È possibile che si desideri specificare che restituisce Truein alcuni casi.
— Leaky Nun,
5
Ciò ritornerebbe solo Trueper l'ingresso 0 , che non è positivo.
— Dennis,
6

J, 17 16 byte

1 byte viene giocato con una soluzione ancora migliore per miglia.

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

L'idea è la stessa dell'originale ma invece di formare la matrice per operare su diagonali minori formiamo le diagonali al volo.

Originale

Per ottenere i primi n fibonomiali:

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

Lettura da destra a sinistra ...
Crea l'array di numeri interi consecutivi ( i.) fino a uno specificato, da quell'array crea la tabella ( /~) dei coefficienti binomiali ( !) calcolata da ogni coppia dell'array, questa tabella è il triangolo di Pascal all'inizio del la fine della prima riga e tutti gli elementi sotto la diagonale principale sono 0, per fortuna all'implementazione di !. Se sommi ( +/) tutte le diagonali minori ( /.), ottieni i numeri di Fibonacci, ma devi prendere ( {.) tanto i primi elementi dell'array risultante quanto la lunghezza ( #) della tabella stessa. Quindi il prodotto (*/ ) applicato a prefissi consecutivi ( \) dell'array risulta nella sequenza desiderata di fibonorial.Se lo desideri, puoi prendere solo l'ultimo usando altri 2 byte ({:) ma ho pensato che mostrarli tutti non fosse un peccato :).
NB. the previous code block is not a J function.

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

Per i grandi numeri in J si usa xalla fine:

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

Il programma funziona su 0,11 secondi .

   100 timex '{:*/\(#{.+//.)!/~i.100x'
0.112124
— Dan Oak
fonte
1
Un'alternativa che è una funzione sta [:*/+/@(!|.)\@i.usando 16 byte. Forma gli stessi coefficienti binomiali lungo la tabella che generi usando !/~tranne che lo forma prendendo i prefissi di i..
— miglia
4

Pyth, 13 byte

u*Gs=[sZhZ)Q1

Dimostrazione

Questo impiega un trucco intelligente, non tipicamente sicuro. Cinque dei personaggi (u*G ... Q1 ) dicono che l'output è il prodotto dell'input di molti numeri. Il resto del codice genera i numeri.

=[sZhZ)aggiorna la variabile Zall'elenco [s(Z), h(Z)]. Quindi ssomma quell'elenco, da moltiplicare.

Zè inizialmente 0. s, su ints, è la funzione identità. h, sulla sua, è la + 1funzione. Quindi alla prima iterazione, Zdiventa [0, 1]. ssu liste è la funzione di somma, come menzionato sopra. hè la funzione principale. Quindi la seconda iterazione è [1, 0].

Ecco un elenco:

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

Queste somme vengono moltiplicate per dare il risultato.

— isaacg
fonte
4

Mathematica 25 24 byte

Grazie a Martin Ender.

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

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

Tempi: 63 microsecondi.

{0.000063, 
3371601853146468125386964065447576689828006172937411310662486977801540
6711385898686165008341900290675836651822917015531720110825745874313823
1009903039430687777564739516714333248356092511296002464445971530050748
1235056111434293619038347456390454209587101225261757371666449068625033
9995735521655245297254676280601708866020010771376138030271586483293355
0772869860576999281875676563330531852996518618404399969665040724619325
7877568825245646129366994079739720698147440310773871269639752334356493
6789134243905645353892122400388956268116279491329780860702550826683922
9003714114129148483959669418215206272639036409444764264391237153249138
8089634845995941928089653751672688740718152064107169357399466473375804
9722605947689699525073466941890502338235963164675705844341280523988912
2373033501909297493561702963891935828612435071136036127915741683742890
4150054292406756317837582840596331363581207781793070936765786629772999
8328572573496960944166162599743042087569978353607028409125185326833249
36435856348020736000000000000000000000000}
— DavidC
fonte
In alternativa, con lo stesso numero di byte:1##&@@Fibonacci~Array~#&
— Greg Martin
4

Gelatina, 8 byte

RḶUc$S€P

La mia prima presentazione in Jelly. Non è breve come la risposta di @Dennis , ma è solo 2 byte in più con un metodo diverso.

A livello locale, richiede circa 400 ms rispetto a 380 ms con la versione di @Dennis per n = 100.

Provalo online!

Spiegazione

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
— miglia
fonte
3

PARI / GP, 29 byte

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

O in alternativa:

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

R, 99 96 78 76 66 byte

Questa risposta utilizza la formula di Binet e la prod(x)funzione. Poiché R non ha un Phivalore predefinito, l'ho definito da solo:

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

Funziona in meno di 5 secondi, ma R tende a dareInf una risposta per quei grandi numeri ...

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 byte grazie a @Cyoce!
Oh, adoro questo sito! -10 byte grazie a @ user5957401

— Frédéric
fonte
Potrebbe essere in grado di salvare un po 'memorizzando sqrt(5)in una variabile
— Cyoce
poiché lo usi solo Nuna volta, puoi semplicemente chiamare scan all'interno del 1:Nbit. vale a dire for(n in 1:scan()). Puoi anche salvare alcuni caratteri semplicemente usando al *posto della prod()funzione nel tuo ciclo for. Il tuo ciclo for è solo una riga, quindi non hai nemmeno bisogno delle parentesi graffe.
— user5957401
Bella idea usare la formula di Binet. Nel tuo spirito, ma solo 53 byte èfunction(n,N=1:n,p=5^.5)prod(((1+p)^N-(1-p)^N)/2^N/p)
— Michael M,
3

R, 82 , 53 , 49 byte (48 byte con diverso stile di input)

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

Se possiamo solo precedere il codice con il numero di input, otteniamo il 48 byte

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

EDIT: nuovo codice. L'originale è sotto:

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)})

a(100)Tuttavia, non restituirà altro che Inf . E non funzionerà per nient'altro che numeri interi non negativi.

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
fonte
3

Java, 165 byte

golfed:

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];}

Questo è un altro caso in cui BigIntegerè richiesto a causa di grandi numeri. Tuttavia, sono stato in grado di ridurre al minimo il testo BigInteger, mantenendo le dimensioni ridotte. Ho anche confrontato con le importazioni statiche e ha allungato la lunghezza totale.

Questo programma funziona monitorando tre numeri in un array. I primi due sono i precedenti due numeri di Fibonacci. Il terzo è il valore accumulato. Il ciclo inizia calcolando il valore successivo e memorizzandolo in indici di array alternati (0, 1, 0, 1, ...). Questo evita la necessità di spostare i valori con operazioni di assegnazione costose (in termini di dimensioni della fonte). Quindi prendi quel nuovo valore e moltiplicalo nell'accumulatore.

Evitando oggetti temporanei e limitando il loop a due operatori di assegnazione, sono stato in grado di estrarre parecchi byte.

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

}

Uscita del programma:

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

Rubino, 39 byte

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

Javascript (ES6), 51 39 byte

Implementazione ricorsiva (39 byte)

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

Implementazione originale (51 byte)

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

Nota: inizia gli errori di arrotondamento per il Fibonacci-orial di 16, 100 è solo Infinity, viene eseguito in quello che sembra essere <1 secondo.

— Pandacoder
fonte
Ho creato una versione alternativa a 53 byte n=>[...Array(n)].reduce(p=>(c=a,a=b,p*=b+=c),a=1,b=0)solo per scoprire che avevi contato quello f=che non è necessario salvandoti 2 byte.
— Neil,
Punto valido. La mia logica era quindi era richiamabile e riutilizzabile piuttosto che solo richiamabile.
— Pandacoder,
Certo, ma se qualcuno vuole riutilizzarlo, ha comunque la possibilità di nominarlo.
— Neil,
@Neil Bene, ora sono andato a implementarlo nuovamente e ora f = è obbligatorio, altrimenti non può essere eseguito. : D
— Pandacoder
Beh, almeno hai corretto il conteggio dei byte per l'implementazione originale.
— Neil,
2

DC (GNU o OpenBSD) , 36 byte

File A003266-v2.dc:

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

(nessuna nuova riga finale)

... ora il risultato viene mantenuto nello stack invece di utilizzare un registro con nome (è Ynella versione 1). Il rcomando non è disponibile nell'originale dc(consultare la pagina Dc di RosettaCode ).

Correre:

$ 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

Cercando di spiegare:

tosè il contenuto della parte superiore della pila senza rimuoverlo.
nosè l'elemento sotto 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 byte

... dritto, nessun trucco:

File A003266-v1.dc:

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

(nessuna nuova riga finale)

Correre:

$ 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
* sigh! * ... scrivere dccodice è sicuramente più semplice che spiegarlo ...
1
Sì, abbiamo davvero bisogno di un IDE con una sorta di pazzo gadget di visualizzazione multi-stack ... sarebbe dolce.
— Joe
1
Ho diverse idee su cosa aggiungere come nuovi comandi, ma l'idea con il maggiore impatto sembra essere: Aggiungi un comando "cambia stack predefinito". ;-)
2
... o scambia lo stack predefinito con un registro denominato. Ciò farebbe più nodi nel cervello degli utenti ma non avrebbe bisogno dello stack predefinito per avere un nome ...] :-)
1
Sì, sarebbe sicuramente utile! Vorrei anche cancellare un singolo oggetto, ruotare gli oggetti che non sono in cima alla pila e forse spostare gli noggetti migliori in un'altra pila contemporaneamente. Per ora, comunque, non so ancora come compilare dcdal sorgente. : /
— Joe
2

C # 110 109 107 103 101 94 94 byte

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;}

Spiegazione

//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;
}

Algoritmo Iterative Fib

— JustinM: ripristina Monica
fonte
Dato che questo ha funzionato molto meglio di quanto mi aspettassi volevo trovare la N massima che sarebbe tornata in meno di 5 secondi, sono uscito con 1540 che dà un numero lungo 247441 cifre.
— JustinM - Ripristina Monica l'
Impressionante. Quanto tempo impiega il 1541 per calcolare, per curiosità?
— Pandacoder
@Pandacoder Quindi con la recente modifica dell'algoritmo è diventato molto più veloce. 1541 tra 755 ms quindi ora troverò il nuovo sub 5 max.
— JustinM - Ripristina Monica il
@Pandacoder quindi il tempo di esecuzione varia di un bel po '~ 100ms ma 2565 sembra in media circa 5 secondi
— JustinM - Reinstate Monica
Quanto dura questo numero?
— Pandacoder,
2

Brain-Flak , 54 byte

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

Provalo online!

La moltiplicazione in Brain-Flak richiede molto tempo per input di grandi dimensioni. Basta moltiplicare F 100 per F 99 con un algoritmo di moltiplicazione generico richiederebbe miliardi di anni.

Fortunatamente, c'è un modo più veloce. Una sequenza di Fibonacci generalizzata che inizia con (k, 0)genererà gli stessi termini della sequenza normale, moltiplicata per k. Usando questa osservazione, Brain-Flak può moltiplicarsi per un numero di Fibonacci con la stessa facilità con cui può generare numeri di Fibonacci.

Se lo stack è composto -nda due numeri seguiti, {({}()<([({})]({}{}))>)}{}{}calcolerà le niterazioni della sequenza di Fibonacci generalizzata e scarterà tutto dall'ultimo. Il resto del programma imposta solo l'1 iniziale e lo fa scorrere per tutti i numeri nell'intervallo n...1.

Ecco lo stesso algoritmo nelle altre lingue fornito da questo interprete:

Brain-Flak Classic, 52 byte

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

Provalo online!

Brain-Flueue, 58 byte

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

Provalo online!

Mini-Flak, 62 byte

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

Provalo online!

— Nitrodon
fonte
1

Mathematica - 32 26 byte

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

@MartinEnder ha tagliato i 6 byte!

— Yytsi
fonte
1

Rubino, 85 byte

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

Si è rivelato bene, ma probabilmente c'è una soluzione più breve.

Fast Fibonnaci calculation taken from here: link

Test it here

— Seims
fonte
1

Julia, 36 bytes

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

Brain-Flak, 110 104 100 bytes

Try it online!

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

Explanation

First we run an improved version of the Fibonacci sequence generator curtesy of Dr Green Eggs and Iron Man

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

Then while the stack has more than one item on it

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

multiply the top two items

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

and pop the extra zero

{}
— Wheat Wizard
fonte
1
Unfortunately, I think this is invalid since it takes over 10 seconds for an input of 25. The algorithm is very inefficient (just like the language is), so calculating it for 100 would probably take hours.
— DJMcMayhem
1

Clojure, 70 bytes

Clojure isn't really a good language for code golf. Oh well.

Try it at http://tryclj.com.

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

Forth, 55 bytes

Uses an iterative approach, built upon my Fibonacci answer in Forth. The results overflow arithmetically for n > 10. The answer is case-insensitive.

: f >r 1 1 r@ 0 DO 2dup + LOOP 2drop 1 r> 0 DO * LOOP ;

Try it online

— mbomb007
fonte
1

JavaScript (ES6), 46 bytes

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

Uses recursion and accumulator variables. Rounding errors start at f(16).

— c.P.u1
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.