Fibonacci-orial

36

Definición

La secuencia de Fibonacci F(n), en los enteros positivos, se define como tal:

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

El Fibonacci-orial de un entero positivo es el producto de [F(1), F(2), ..., F(n)].

Tarea

Dado entero positivo n, encuentre el Fibonacci-orial de n.

Especificaciones

El fibonacci-orial de 100debe computar en menos de 5 segundos en una computadora razonable.

Casos de prueba

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

Referencias

Monja permeable
fuente
Relacionados .
Leaky Nun
1
@LuisMendo La suma de fibonacci es ... lo has adivinado, fibonacci. Bueno, menos uno.
Leaky Nun
2
@LeakyNun Actualmente, la respuesta de JavaScript solo completa los casos de prueba hasta 15 porque JavaScript no puede comparar (o manipular) correctamente los números más allá de 2 ^ 53 - 1. Esto es muy similar para muchas de las presentaciones aquí, porque la mayoría de los idiomas no números de apoyo tan grandes
MayorMonty
1
¿Qué quieres decir con "computadora razonable"?
Erik the Outgolfer
2
-1 porque esto parece varios desafíos juntos (rango, fibonacci de cada uno, factorial) sin atajos particularmente interesantes.
Esolanging Fruit

Respuestas:

63

Mathematica, 10 bytes

Fibonorial

Otro Mathematica incorporado es golpeado por un lenguaje de golf sin el incorporado.

Martin Ender
fuente
49
Yo ... ¿qué ... por qué, Mathematica?
Lynn
3
¡Olvidé que esa función incluso existía!
LegionMammal978
3
@Lynn Regla 35 : Si existe, hay una función de Mathematica;)
Beta Decay
99
@BetaDecay Pensé que habíamos establecido que es la Regla 110 .
Martin Ender
1
No, la Regla 110 es algo muy diferente. Aunque estoy seguro de que Mathematica también tiene una función incorporada para eso.
AdmBorkBork
27

Jalea , 6 bytes

+С1ḊP

La entrada 100 termina en 500 ms localmente. Pruébalo en línea!

Cómo funciona

+С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
fuente
Entonces, ¿es +¡1un enésimo fibonacci no construido y +С1son los primeros n números de Fibonacci?
caird coinheringaahing
@cairdcoinheringaahing Bastante.
Dennis
¿Pensé que había una función de Fibonacci incorporada?
MilkyWay90
21

En realidad , 4 bytes

Ejecuta la entrada 100 en 0.2 segundos. Código:

R♂Fπ

Explicación:

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

Utiliza la codificación CP-437 . Pruébalo en línea! .

Adnan
fuente
1
Esta es la herramienta adecuada para el trabajo :) Gracias a algunas mejoras en la función Fibonacci que Leaky Nun realizó hace un tiempo, el caso de prueba 100 se ejecuta en 0.1 segundos en TIO .
Mego
16

Brainfuck, 1198 1067 817 770 741 657 611 603

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

Sin comprimir, con comentarios:

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

Pruébalo en línea!

El tiempo de ejecución para n = 100 es menos de 1 segundo con el intérprete en línea (aproximadamente 0.2 s localmente con mi propio intérprete). La entrada máxima es 255, pero requeriría que el intérprete admita ~ 54000 celdas (el intérprete en línea parece ajustarse a 64k).


Cambiar registro

Se ahorraron alrededor de 130 bytes con una mejor extracción del dígito actual para multiplicar por y combinando agregar y transportar en una sola pasada. También parece ser un poco más rápido.

Guardado otros 250 bytes. Logré reducir mi bloc de notas de multiplicación en dos celdas, lo que ahorra bytes en casi todas partes al no tener que cambiar tanto entre dígitos. También dejé caer el acarreo después de multiplicarlo por un dígito, y en su lugar realicé un acarreo completo mientras agregué el total acumulado.

Cortó otros 50, nuevamente con una mejor extracción del dígito actual para multiplicarlo, simplemente no moviéndolo hacia adelante la primera iteración y trabajando desde donde está. Algunas micro optimizaciones más abajo representan alrededor de ~ 10 bytes.

30 más desaparecidos. Marcar los dígitos que ya se han tomado con un 0 en lugar de un 1 hace que sean más fáciles de localizar. También hace que la verificación de si el ciclo de multiplicación ha terminado sea algo más simple.

Reduje el bloc de notas por otra celda, por 80 bytes más. Hice esto fusionando el marcador para el producto anterior y el total actual, lo que reduce los cambios entre las brechas y facilita un poco la contabilidad.

Salvó otros 50, al eliminar otra celda, reutilizando el marcador para los dígitos de Fibonacci para marcar el último dígito tomado también. También pude fusionar el ciclo para cambiar los totales anteriores con el ciclo de multiplicación de dígitos.

Guardado 8 bytes en el análisis de entrada. Ups

primo
fuente
14

Python, 45 bytes

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

La entrada se toma de stdin. La salida para n = 100 termina demasiado rápido como para medir el tiempo con precisión. n = 1000 toma aproximadamente 1s.

Uso de muestra

$ echo 10 | python fib-orial.py
122522400

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

Haskell 41 29 Bytes

1 + 11 bytes guardados por los comentarios de @ Laikoni.

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

1, fy !!son tokens separados. La primera línea define la secuencia de Fibonacci, la segunda es una función que calcula la secuencia de fibonacci-oriales y devuelve el enésimo para un n dado. Comienza a imprimir dígitos casi de inmediato incluso para n = 1000.

Christian Sievers
fuente
1
Puedes deshacerte del espacio (scanl(*)1f!!).
Laikoni
2
Y hay un generador de Fibonacci más corto aquí :f=1:scanl(+)1f
Laikoni
@Laikoni Eso es increíble, ¡gracias!
Christian Sievers
2
@ WillNess Creo que no solo estoy justificado por lo que hacen otros usuarios, sino también por meta.codegolf.stackexchange.com/questions/2419/… y meta.codegolf.stackexchange.com/questions/9031/… (pero hay un mucho más y no he leído todo)
Christian Sievers
1
@flawr ¿Aceptaría 42+como una función que agrega 42? No deberías, porque es solo una expresión inacabada. Pero en Haskell podemos agregar paréntesis y obtener el sección (42+) , una forma de escribir la función \n->42+n. Aquí es lo mismo, solo con !!(el operador infijo binario para la indexación) en lugar de +un primer operando más complicado.
Christian Sievers
11

Python 2, 39 bytes

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

Pruébalo en Ideone .

Dennis
fuente
Es posible que desee especificar que vuelve Trueen algunos casos.
Monja goteante
55
Esto solo volvería Truepara la entrada 0 , que no es positiva.
Dennis
6

J, 17 16 bytes

1 byte se juega con una solución aún mejor por millas.

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

La idea es la misma que la original, pero en lugar de formar la matriz para operar en diagonales menores, formamos las diagonales sobre la marcha.


Original

Para obtener el primero n fibonomiales:

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

Lectura de derecha a izquierda ...
Cree la matriz de enteros consecutivos ( i.) hasta uno especificado, a partir de esa matriz cree la tabla ( /~) de coeficientes binomiales ( !) calculados a partir de cada par en la matriz, esta tabla es la parte superior triangular de Pascal en al final de la primera fila y todos los elementos debajo de la diagonal principal son 0, afortunadamente para la implementación de !. Si sumas ( +/) todas las diagonales menores ( /.), obtienes números de Fibonacci, pero necesitas tomar ( {.) tanto de los primeros elementos de la matriz resultante como la longitud ( #) de la tabla misma. Luego, el producto ( */) aplicado a prefijos consecutivos ( \) de la matriz da como resultado la secuencia deseada de fibonoriales.Si lo desea, puede tomar solo el último usando 2 bytes más ( {:) pero pensé que mostrarlos no es pecado :).
NB. the previous code block is not a J function.

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

Para los números grandes en J que usa xal final:

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

El programa se ejecuta en Avarage 0.11s .

   100 timex '{:*/\(#{.+//.)!/~i.100x'
0.112124
Dan Oak
fuente
1
Una alternativa que es una función es [:*/+/@(!|.)\@i.usar 16 bytes. Forma los mismos coeficientes binomiales a lo largo de la tabla que genera utilizando, !/~excepto que lo forma tomando prefijos de i..
millas
4

Pyth, 13 bytes

u*Gs=[sZhZ)Q1

Demostración

Esto emplea un ingenioso truco no seguro para los tipos. Cinco de los personajes (u*G ... Q1 ) dicen que la salida es el producto de la entrada de muchos números. El resto del código genera los números.

=[sZhZ)actualiza la variable Za la lista [s(Z), h(Z)]. Luego ssuma esa lista, para ser multiplicada.

Zes inicialmente 0. s, en ints, es la función de identidad. h, en su, es la + 1función. Entonces, en la primera iteración,Z convierte en [0, 1]. sen las listas está la función de suma, como se mencionó anteriormente. hEs la función de la cabeza. Entonces la segunda iteración es [1, 0].

Aquí hay una lista:

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

Estas sumas se multiplican para dar el resultado.

isaacg
fuente
4

Mathematica 25 24 bytes

Gracias a Martin Ender.

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

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

Tiempo: 63 microsegundos.

{0.000063, 
3371601853146468125386964065447576689828006172937411310662486977801540
6711385898686165008341900290675836651822917015531720110825745874313823
1009903039430687777564739516714333248356092511296002464445971530050748
1235056111434293619038347456390454209587101225261757371666449068625033
9995735521655245297254676280601708866020010771376138030271586483293355
0772869860576999281875676563330531852996518618404399969665040724619325
7877568825245646129366994079739720698147440310773871269639752334356493
6789134243905645353892122400388956268116279491329780860702550826683922
9003714114129148483959669418215206272639036409444764264391237153249138
8089634845995941928089653751672688740718152064107169357399466473375804
9722605947689699525073466941890502338235963164675705844341280523988912
2373033501909297493561702963891935828612435071136036127915741683742890
4150054292406756317837582840596331363581207781793070936765786629772999
8328572573496960944166162599743042087569978353607028409125185326833249
36435856348020736000000000000000000000000}
DavidC
fuente
Alternativamente, con el mismo recuento de bytes:1##&@@Fibonacci~Array~#&
Greg Martin
4

Jalea, 8 bytes

RḶUc$S€P

Mi primera sumisión en Jelly. No es tan corto como la respuesta de @Dennis , pero solo tiene 2 bytes más con un método diferente.

A nivel local, requiere unos 400 ms en comparación con 380 ms con la versión de @Dennis para n = 100.

Pruébalo en línea!

Explicación

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
millas
fuente
3

PARI / GP, 29 bytes

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

O alternativamente:

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

R, 99 96 78 76 66 bytes

Esta respuesta es utiliza la fórmula de Binet , así como la prod(x)función. Como R no tiene un Phivalor incorporado, lo definí yo mismo:

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

Funciona en menos de 5 segundos, pero R tiende a dar Infuna respuesta para esos números grandes ...

Sin golf:

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 gracias a @Cyoce!
¡Oh, me encanta este sitio! -10 bytes gracias a @ user5957401

Frédéric
fuente
Podría ahorrar un poco almacenando sqrt(5)en una variable
Cyoce
Como solo lo usa Nuna vez, puede llamar a scan dentro del 1:Nbit. es decir for(n in 1:scan()). También puede guardar algunos caracteres simplemente usando en *lugar de la prod()función en su bucle for. Su bucle for es solo una línea, por lo que tampoco necesita las llaves.
user5957401
Buena idea usar la fórmula de Binet. En tu espíritu, pero solo 53 bytes esfunction(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 con un estilo de entrada diferente)

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

Si solo podemos preceder el código con el número de entrada, obtenemos el byte de 48

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

EDITAR: Nuevo código. El original está debajo:

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

No devolverá nada más que Inf para a(100) embargo, . Y no funcionará para nada más que enteros no negativos.

Sin golf:

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)
}
usuario5957401
fuente
3

Java, 165 bytes

Golfizado:

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

Este es otro caso en el que BigIntegerse requiere debido a los grandes números. Sin embargo, pude guardar el textoBigInteger al mínimo, manteniendo el tamaño bajo. También lo comparé con las importaciones estáticas, e hizo que la longitud total fuera más larga.

Este programa funciona rastreando tres números en una matriz. Los dos primeros son los dos números anteriores de Fibonacci. El tercero es el valor acumulado. El ciclo comienza calculando el siguiente valor y almacenándolo en índices de matriz alternos (0, 1, 0, 1, ...). Esto evita la necesidad de cambiar valores con operaciones de asignación costosas (en términos de tamaño de fuente). Luego toma ese nuevo valor y multiplícalo en el acumulador.

Al evitar objetos temporales y limitar el bucle a dos operadores de asignación, pude extraer bastantes bytes.

Sin golf:

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

}

Salida del programa:

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

fuente
2

Ruby, 39 bytes

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

Javascript (ES6), 51 39 bytes

Implementación recursiva (39 bytes)

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

Implementación original (51 bytes)

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

Nota: Inicia errores de redondeo para el Fibonacci-orial de 16, 100 es solo Infinity, se ejecuta en lo que parece ser <1 segundo.

Pandacoder
fuente
Hice una versión alternativa de 53 bytes n=>[...Array(n)].reduce(p=>(c=a,a=b,p*=b+=c),a=1,b=0)solo para descubrir que había contado lo f=que no es necesario para ahorrarle 2 bytes.
Neil
Punto justo. Mi razón era que era invocable y reutilizable en lugar de simplemente invocable.
Pandacoder
Claro, pero si alguien quiere reutilizarlo, entonces todavía tiene la opción de nombrarlo.
Neil
@Neil Bueno, ahora fui y lo volví a implementar y ahora f = es obligatorio o no se puede ejecutar. : D
Pandacoder
Bueno, al menos arregló el recuento de bytes para la implementación original.
Neil
2

DC (sabor GNU o OpenBSD) , 36 bytes

Archivo A003266-v2.dc:

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

(sin línea nueva)

... ahora el resultado se mantiene en la pila en lugar de usar un registro con nombre (está Yen la versión 1). losr comando no está disponible en el original dc(vea la página de Dc de RosettaCode ).

Correr:

$ 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

Tratando de explicar:

toses el contenido de la parte superior de la pila sin quitarlo.
noses el elemento a continuación 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

corriente continua , 41 bytes

... sencillo, sin trucos:

Archivo A003266-v1.dc:

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

(sin línea nueva)

Correr:

$ 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

fuente
1
* suspiro * ... escribir dccódigo definitivamente es más fácil que explicarlo ...
1
Sí, realmente necesitamos un IDE con algún tipo de dispositivo de visualización loco de varias pilas ... eso sería genial.
Joe
1
Tengo varias ideas sobre qué agregar como nuevos comandos, pero la idea con el mayor impacto parece ser: Agregar un comando "cambiar pila predeterminada". ;-)
2
... o intercambie la pila predeterminada con un registro con nombre. Eso haría más nudos en el cerebro de los usuarios, pero no necesitaría la pila predeterminada para tener un nombre ...] :-)
1
Sí, eso definitivamente sería útil. También me gustaría borrar un solo elemento, rotar los elementos que no están en la parte superior de la pila y quizás cambiar los nelementos superiores a otra pila a la vez. Por ahora, sin embargo, todavía no sé cómo compilar dcdesde la fuente. : /
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;}

Explicación

//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 Iterativo de Fib

JustinM - Restablece a Monica
fuente
Dado que esto funcionó mucho mejor de lo que esperaba, quería encontrar el N máximo que regresaría en menos de 5 segundos, obtuve 1540, lo que da un número de 247441 dígitos.
JustinM - Restablece a Mónica el
Impresionante. ¿Cuánto tiempo tarda 1541 en calcular, por curiosidad?
Pandacoder
@Pandacoder Entonces, con el reciente cambio en el algoritmo, se ha vuelto significativamente más rápido. 1541 en 755 ms, así que voy a encontrar el nuevo sub 5 max ahora.
JustinM - Restablece a Mónica el
@Pandacoder por lo que el tiempo de ejecución es variable por un poco justo ~ 100 ms, pero 2565 parece promedio alrededor de 5 segundos
JustinM - Restablecer Monica
¿Cuánto dura el número para eso?
Pandacoder
2

Brain-Flak , 54 bytes

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

Pruébalo en línea!

La multiplicación en Brain-Flak lleva mucho tiempo para grandes entradas. Simplemente multiplicar F 100 por F 99 con un algoritmo de multiplicación genérico llevaría miles de millones de años.

Afortunadamente, hay una forma más rápida. Una secuencia de Fibonacci generalizada que comience (k, 0)generará los mismos términos que la secuencia habitual, multiplicada por k. Usando esta observación, Brain-Flak puede multiplicarse por un número de Fibonacci tan fácilmente como puede generar números de Fibonacci.

Si la pila consta de -ndos números seguidos, {({}()<([({})]({}{}))>)}{}{}calculará las niteraciones de la secuencia generalizada de Fibonacci y las descartará por la última. El resto del programa simplemente configura el 1 inicial y recorre esto para todos los números en el rango n...1.

Aquí está el mismo algoritmo en los otros idiomas proporcionados por este intérprete:

Brain-Flak Classic, 52 bytes

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

Pruébalo en línea!

Flujo cerebral, 58 bytes

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

Pruébalo en línea!

Mini-Flak, 62 bytes

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

Pruébalo en línea!

Nitrodon
fuente
1

Mathematica - 32 26 bytes

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

¡@MartinEnder cortó 6 bytes!

Yytsi
fuente
1

BRECHA 28 Bytes

No sabía antes de hoy que GAP tiene un Fibonacciincorporado.

n->Product([1..n],Fibonacci)
Christian Sievers
fuente
¿Se puede vincular a GAP? Ni idea de lo que es.
Leaky Nun
Oh, claro (pero no soy el primero en usarlo aquí ...)
Christian Sievers
1

Rubí, 85 bytes

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

Resultó bien, pero probablemente haya una solución más corta.

Cálculo rápido de Fibonnaci tomado de aquí: enlace

Pruébalo aquí

Seims
fuente
1

Julia, 36 bytes

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

Cerebro-Flak , 110 104 100 bytes

Pruébalo en línea!

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

Explicación

Primero ejecutamos una versión mejorada del generador de secuencia de Fibonacci, cortesía del Dr. Green Eggs y Iron Man

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

Luego, mientras la pila tiene más de un elemento

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

multiplica los dos primeros elementos

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

y saca el cero extra

{}
Asistente de trigo
fuente
1
Desafortunadamente, creo que esto no es válido ya que lleva más de 10 segundos para una entrada de 25. El algoritmo es muy ineficiente (al igual que el lenguaje), por lo que calcularlo para 100 probablemente tomaría horas.
DJMcMayhem
1

Clojure, 70 bytes

Clojure no es realmente un buen lenguaje para el golf de código. Oh bien.

Pruébalo en http://tryclj.com .

(last(nth(iterate(fn[[a b r]][b(+ a b)(* r(+ a b))])[0N 1 1])(dec n)))
usuario16973
fuente
1

Adelante, 55 bytes

Utiliza un enfoque iterativo, basado en mi respuesta de Fibonacci en Forth. Los resultados se desbordan aritméticamente para n > 10. La respuesta no distingue entre mayúsculas y minúsculas.

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

Pruébalo en línea

mbomb007
fuente
1

Rápido, 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 - Restablece a Monica
fuente
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)

Utiliza recursividad y variables de acumulación. Los errores de redondeo comienzan en f(16).

cPu1
fuente