Fibonacci-orial


36

Definisi

Urutan Fibonacci F(n), pada bilangan bulat positif, didefinisikan sebagai berikut:

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

Fibonacci-orial dari bilangan bulat positif adalah produk dari [F(1), F(2), ..., F(n)].

Tugas

Diberikan bilangan bulat positif n, temukan Fibonacci-orial dari n.

Spesifikasi

The fibonacci-orial of 100harus menghitung di bawah 5 detik pada komputer yang masuk akal.

Testcases

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

Referensi



1
@LuisMendo Jumlah fibonacci adalah ... Anda sudah menebaknya, fibonacci. Ya, minus satu.
Leaky Nun

2
@LeakyNun Saat ini, jawaban JavaScript hanya menyelesaikan kasus pengujian hingga 15 karena JavaScript tidak dapat dengan benar membandingkan (atau memanipulasi) angka di atas 2 ^ 53 - 1. Ini kemungkinan besar mirip dengan banyak pengiriman di sini, karena sebagian besar bahasa tidak nomor dukungan yang besar
MayorMonty

1
Apa yang Anda maksud dengan "komputer yang masuk akal"?
Erik the Outgolfer

2
-1 karena ini sepertinya beberapa tantangan yang diatasi bersama (kisaran, Fibonacci dari masing-masing, faktorial) tanpa pintasan yang sangat menarik.
Buah Esolanging

Jawaban:


63

Mathematica, 10 byte

Fibonorial

Built-in Mathematica lain dipukuli dengan baik oleh bahasa golf tanpa built-in.


49
Aku ... a-apa ... mengapa, Mathematica ?!
Lynn

3
Lupa fungsi itu bahkan ada!
LegionMammal978

3
@Lynn Aturan 35 : Jika ada, ada fungsi Mathematica;)
Beta Decay

9
@ BetaDecay, saya pikir kami telah menetapkan bahwa itu adalah Aturan 110 .
Martin Ender

1
Tidak, Aturan 110 adalah sesuatu yang sangat berbeda. Meskipun saya yakin Mathematica memiliki built-in untuk itu juga.
AdmBorkBork

27

Jelly , 6 byte

+С1ḊP

Input 100 selesai dalam 500 ms secara lokal. Cobalah online!

Bagaimana itu bekerja

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

Jadi, apakah +¡1non-built in nth fibonacci dan +С1n bilangan Fibonacci pertama?
caird coinheringaahing

@cairdcoinheringaahing Cukup banyak.
Dennis

Saya pikir ada fungsi fibonacci bawaan?
MilkyWay90

21

Sebenarnya , 4 byte

Menjalankan input 100 dalam 0,2 detik. Kode:

R♂Fπ

Penjelasan:

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

Menggunakan pengkodean CP-437 . Cobalah online! .


1
Ini adalah alat yang tepat untuk pekerjaan ini :) Berkat beberapa perbaikan pada fungsi Fibonacci yang Leaky Nun buat beberapa waktu lalu, 100 test case berjalan dalam 0,1 detik pada TIO .
Mego

16

Brainfuck, 1198 1067 817 770 741 657 611 603

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

Terkompresi, dengan komentar:

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

Cobalah online!

Runtime untuk n = 100 kurang dari 1 detik dengan penerjemah online (sekitar 0,2 detik menggunakan interpreter saya sendiri). Input maksimum adalah 255, tetapi akan membutuhkan penerjemah untuk mendukung ~ 54000 sel (penerjemah online tampaknya menggunakan 64k).


Ubah Log

Disimpan sekitar 130 byte dengan ekstraksi yang lebih baik dari digit saat ini untuk dikalikan dengan, dan dengan menggabungkan menambah dan membawa ke dalam satu pass. Tampaknya juga sedikit lebih cepat.

Menyimpan 250 byte lagi. Saya berhasil mengurangi multiplikasi goresan dua sel, yang menghemat byte di mana-mana dengan tidak harus bergeser sejauh ini di antara digit. Saya juga menjatuhkan carry setelah mengalikannya dengan digit, dan sebagai gantinya melakukan carry penuh sambil menambah total running.

Cincang 50 lagi, lagi dengan ekstraksi yang lebih baik dari digit saat ini untuk dikalikan, hanya dengan tidak bergerak maju iterasi pertama, dan bekerja dari tempat itu. Beberapa optimasi mikro lebih lanjut menyumbang sekitar ~ 10 byte.

30 lagi hilang. Menandai digit yang telah diambil dengan angka 0 daripada angka 1 membuatnya lebih mudah ditemukan. Itu juga membuat pemeriksaan apakah loop multiplikasi telah selesai agak lebih sederhana.

Saya mengurangi bantalan awal dengan sel lain, untuk 80 byte lebih. Saya melakukan ini dengan menggabungkan penanda untuk produk sebelumnya dan total berjalan saat ini, yang mengurangi pergeseran antara celah, dan membuat pembukuan sedikit lebih mudah.

Menyimpan 50 lainnya, dengan menghilangkan sel lagi, menggunakan kembali marker untuk digit fibonacci untuk menandai digit terakhir yang diambil juga. Saya juga bisa menggabungkan loop untuk menggeser total sebelumnya dengan loop multiplikasi digit-wise.

Disimpan 8 byte pada parsing input. Ups.


14

Python, 45 Bytes

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

Input diambil dari stdin. Output untuk n = 100 selesai terlalu cepat untuk waktu yang akurat. n = 1000 membutuhkan waktu sekitar 1s.

Contoh Penggunaan

$ echo 10 | python fib-orial.py
122522400

$ echo 100 | python fib-orial.py
3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000

13

Haskell 41 29 Bytes

1 + 11 byte disimpan oleh pernyataan @ Laikoni.

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

1, fdan !!merupakan token yang terpisah. Baris pertama mendefinisikan urutan fibonacci, yang kedua adalah fungsi yang menghitung urutan fibonacci-orials dan mengembalikan n-th untuk n yang diberikan. Ini mulai mencetak angka segera bahkan untuk n = 1000.


1
Anda dapat menyingkirkan ruang (scanl(*)1f!!).
Laikoni

2
Dan ada generator fibonacci lebih pendek di sini :f=1:scanl(+)1f
Laikoni

@Laikoni Itu luar biasa, terima kasih!
Christian Sievers

2
@ WillNess Saya pikir saya tidak hanya dibenarkan oleh apa yang dilakukan pengguna lain, tetapi juga oleh meta.codegolf.stackexchange.com/questions/2419/… dan meta.codegolf.stackexchange.com/questions/9031/… (tetapi ada lebih banyak dan saya belum membaca semuanya)
Christian Sievers

1
@ flawr Apakah Anda menerima 42+sebagai fungsi yang menambahkan 42? Anda tidak boleh, karena itu hanya ekspresi yang belum selesai. Tetapi di Haskell kita bisa menambahkan tanda kurung dan mendapatkan bagian (42+) , cara untuk menulis fungsinya \n->42+n. Ini dia sama, hanya dengan !!(operator infiks biner untuk pengindeksan) bukan +dan operan pertama yang lebih rumit.
Christian Sievers

11

Python 2, 39 byte

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

Uji di Ideone .


Anda mungkin ingin menentukan bahwa ia kembali Truedalam beberapa kasus.
Bocor Nun

5
Ini hanya akan mengembalikan Trueinput 0 , yang tidak positif.
Dennis

6

J, 17 16 byte

1 byte di-golf-kan dengan solusi yang bahkan lebih baik.

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

Idenya sama dengan aslinya tetapi alih-alih membentuk matriks untuk beroperasi pada diagonal minor, kita membentuk diagonal dengan cepat.


Asli

Untuk mendapatkan yang pertama n fibonomial :

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

Membaca dari kanan ke kiri ...
Buat larik bilangan bulat berurutan ( i.) hingga yang ditentukan, dari larik itu buat tabel ( /~) dari koefisien binomial ( !) yang dihitung dari setiap pasangan dalam larik, tabel ini adalah puncak segitiga Pascal di mana terletak di akhir baris pertama dan semua elemen di bawah diagonal utama adalah 0, untungnya untuk implementasi !. Jika Anda menjumlahkan ( +/) semua diagonal minor ( /.), Anda mendapatkan angka Fibonacci, tetapi Anda perlu mengambil ( {.) sebanyak mungkin elemen pertama dari array yang dihasilkan sebagai panjang ( #) dari tabel itu sendiri. Kemudian produk ( */) yang diterapkan pada awalan berurutan ( \) dari hasil array ke dalam urutan fibonorial yang diinginkan.Jika Anda mau, Anda hanya dapat mengambil yang terakhir menggunakan 2 byte lebih ( {:) tapi saya pikir menampilkan semuanya bukan dosa :).
NB. the previous code block is not a J function.

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

Untuk angka besar di J yang Anda gunakan xdi akhir:

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

Program ini berjalan pada rata-rata 0,11s .

   100 timex '{:*/\(#{.+//.)!/~i.100x'
0.112124

1
Alternatif yang merupakan fungsi [:*/+/@(!|.)\@i.menggunakan 16 byte. Ini membentuk koefisien binomial yang sama di sepanjang tabel yang Anda hasilkan menggunakan !/~kecuali bahwa ia membentuk dengan mengambil awalan i..
mil

4

Pyth, 13 byte

u*Gs=[sZhZ)Q1

Demonstrasi

Ini menggunakan trik yang cerdas dan tidak aman. Lima karakter (u*G ... Q1 ) mengatakan bahwa output adalah produk dari input banyak angka. Sisa kode menghasilkan angka.

=[sZhZ)memperbarui variabel Zke daftar [s(Z), h(Z)]. Kemudian sjumlahkan daftar itu, untuk dikalikan.

Zawalnya 0. s, di int, adalah fungsi identitas. h, pada itu, adalah + 1fungsinya. Jadi pada iterasi pertama, Zjadilah [0, 1]. spada daftar adalah fungsi penjumlahan, seperti yang disebutkan di atas. hadalah fungsi kepala. Jadi iterasi kedua adalah[1, 0] .

Berikut daftarnya:

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

Jumlah ini dikalikan untuk memberikan hasilnya.


4

Mathematica 25 24 byte

Terima kasih kepada Martin Ender.

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

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

Waktu: 63 mikrodetik.

{0.000063, 
3371601853146468125386964065447576689828006172937411310662486977801540
6711385898686165008341900290675836651822917015531720110825745874313823
1009903039430687777564739516714333248356092511296002464445971530050748
1235056111434293619038347456390454209587101225261757371666449068625033
9995735521655245297254676280601708866020010771376138030271586483293355
0772869860576999281875676563330531852996518618404399969665040724619325
7877568825245646129366994079739720698147440310773871269639752334356493
6789134243905645353892122400388956268116279491329780860702550826683922
9003714114129148483959669418215206272639036409444764264391237153249138
8089634845995941928089653751672688740718152064107169357399466473375804
9722605947689699525073466941890502338235963164675705844341280523988912
2373033501909297493561702963891935828612435071136036127915741683742890
4150054292406756317837582840596331363581207781793070936765786629772999
8328572573496960944166162599743042087569978353607028409125185326833249
36435856348020736000000000000000000000000}

Bergantian, dengan jumlah byte yang sama:1##&@@Fibonacci~Array~#&
Greg Martin

4

Jelly, 8 byte

RḶUc$S€P

Kiriman pertama saya di Jelly. Ini tidak sesingkat jawaban @ Dennis , tetapi hanya 2 byte lagi dengan metode yang berbeda.

Secara lokal, ini membutuhkan sekitar 400ms dibandingkan dengan 380ms dengan versi @ Dennis 'untuk n = 100.

Cobalah online!

Penjelasan

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

3

PARI / GP, 29 byte

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

Atau sebagai alternatif:

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

3

R, 99 96 78 76 66 byte

Jawaban ini menggunakan Formula Binet , serta prod(x)fungsinya. Karena R tidak memiliki Phinilai bawaan, saya mendefinisikannya sendiri:

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

Ini bekerja di bawah 5 detik, tetapi R cenderung memberikan Infjawaban untuk angka-angka besar ...

Tidak Disatukan:

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 terima kasih kepada @Cyoce!
Oh, aku suka situs ini! -10 byte terima kasih kepada @ user5957401


Mungkin dapat menyimpan sedikit dengan menyimpan sqrt(5)ke variabel
Cyoce

karena Anda hanya menggunakan Nsekali, Anda bisa memanggil pemindaian di dalam 1:Nbit. yaitu for(n in 1:scan()). Anda juga dapat menyimpan beberapa karakter hanya dengan menggunakan *alih-alih prod()fungsi dalam for for Anda. Loop for Anda hanya satu baris, jadi Anda tidak perlu kurung kurawal.
user5957401

Ide bagus untuk menggunakan formula Binet. Dalam semangat Anda, tetapi hanya 53 byte adalahfunction(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 dengan gaya input berbeda)

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

Jika kita bisa mendahului kode dengan nomor input, kita mendapatkan 48 byte

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

Sunting: Kode baru. Asli di bawah:

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

Tidak akan mengembalikan apa pun selain Inf untuk a(100) . Dan itu tidak akan bekerja untuk apa pun kecuali bilangan bulat non-negatif.

Tidak Disatukan:

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

3

Java, 165 byte

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

Ini adalah kasus lain di mana BigIntegerdiperlukan karena jumlah besar. Namun, saya dapat menyimpan teksBigInteger minimum, menjaga ukurannya tetap rendah. Saya juga membandingkan dengan impor statis, dan itu membuat total panjangnya lebih lama.

Program ini bekerja dengan melacak tiga angka dalam sebuah array. Dua yang pertama adalah dua angka Fibonacci sebelumnya. Yang ketiga adalah nilai akumulasi. Loop dimulai dengan menghitung nilai berikutnya dan menyimpannya dalam indeks array bergantian (0, 1, 0, 1, ...). Ini menghindari perlunya mengubah nilai dengan operasi penugasan yang mahal (dalam hal ukuran sumber). Kemudian ambil nilai baru itu dan gandakan ke akumulator.

Dengan menghindari objek sementara dan membatasi loop ke dua operator penugasan, saya bisa memeras beberapa byte.

Tidak Disatukan:

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

}

Output program:

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 byte

->n{f=i=b=1;n.times{f,i,b=i,f+i,b*f};b}

36: -> n {f = i = b = 1; n.kali {b * = f; i = f + f = i}; b}
GB

2

Javascript (ES6), 51 39 byte

Implementasi rekursif (39 byte)

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

Implementasi asli (51 byte)

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

Note: Starts rounding errors for the Fibonacci-orial of 16, 100 is just Infinity, runs in what appears to be <1 second.


I made an alternate 53-byte version n=>[...Array(n)].reduce(p=>(c=a,a=b,p*=b+=c),a=1,b=0) only to discover that you'd counted the f= which isn't required saving you 2 bytes.
Neil

Fair point. My rationale was so it was callable and reusable rather than just callable.
Pandacoder

Sure, but if someone does want to reuse it then they still have the option of naming it.
Neil

@Neil Well now I went and re-implemented it and now the f= is mandatory or else it can't actually execute. :D
Pandacoder

Yah setidaknya Anda memperbaiki jumlah byte untuk implementasi asli.
Neil

2

DC (rasa GNU atau OpenBSD) , 36 byte

File A003266-v2.dc:

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

(tidak ada baris baru)

... sekarang hasilnya disimpan di tumpukan alih-alih menggunakan register bernama ( Ydalam versi 1). The rperintah ini tidak tersedia dalam bahasa aslinya dc(lihat halaman Dc RosettaCode ini ).

Menjalankan:

$ 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

Mencoba menjelaskan:

tosadalah isi bagian atas tumpukan tanpa mengeluarkannya.
nosadalah elemen di bawah ini 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

... lurus ke depan, tidak ada trik:

File A003266-v1.dc:

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

(tidak ada baris baru)

Menjalankan:

$ 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
* huh! * ... menulis dckode pasti lebih mudah daripada menjelaskannya ...

1
Ya, kami benar-benar membutuhkan IDE dengan beberapa jenis alat visualisasi multi-stack gila ... itu akan manis.
Joe

1
Saya punya beberapa ide untuk ditambahkan sebagai perintah baru, tetapi gagasan dengan dampak tertinggi tampaknya adalah: Tambahkan perintah "ubah tumpukan standar". ;-)

2
... atau tukar tumpukan default dengan register bernama. Itu akan membuat lebih banyak simpul di otak pengguna tetapi tidak memerlukan tumpukan default untuk memiliki nama ...] :-)

1
Ya, itu pasti akan berguna! Saya juga ingin menghapus satu item, memutar item yang tidak ada di atas tumpukan, dan mungkin memindahkan nitem teratas ke tumpukan lain sekaligus. Untuk saat ini, saya masih tidak tahu bagaimana cara mengkompilasi dcdari sumber. : /
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;}

Penjelasan

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

Algoritma Iterative Fib


Mengingat ini melakukan jauh lebih baik daripada yang saya harapkan saya ingin menemukan maks N yang akan kembali dalam waktu kurang dari 5 detik, saya keluar dengan 1540 yang memberikan angka yang panjangnya 247.441 digit.
JustinM

Impresif. Berapa lama 1541 untuk menghitung, karena penasaran?
Pandacoder

@Pandacoder Jadi dengan perubahan algoritma baru-baru ini semakin cepat. 1541 dalam 755 ms jadi saya akan mencari sub 5 max baru sekarang.
JustinM

@Pandacoder so the run time is varying by a fair bit ~100ms but 2565 seems to average about 5 seconds
JustinM - Reinstate Monica

How long is the number for that?
Pandacoder

2

Brain-Flak, 54 bytes

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

Try it online!

Multiplication in Brain-Flak takes a long time for large inputs. Just multiplying F100 by F99 with a generic multiplication algorithm would take billions of years.

Fortunately, there's a faster way. A generalized Fibonacci sequence starting with (k, 0) will generate the same terms as the usual sequence, multiplied by k. Using this observation, Brain-Flak can multiply by a Fibonacci number just as easily as it can generate Fibonacci numbers.

If the stack consists of -n followed by two numbers, {({}()<([({})]({}{}))>)}{}{} will computen iterations of the generalized Fibonacci sequence and discard all by the last. The rest of the program just sets up the initial 1 and loops through this for all numbers in the range n...1.

Here's the same algorithm in the other languages provided by this interpreter:

Brain-Flak Classic, 52 bytes

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

Try it online!

Brain-Flueue, 58 bytes

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

Try it online!

Mini-Flak, 62 bytes

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

Try it online!


1

Mathematica - 32 26 bytes

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

@MartinEnder chopped 6 bytes!



1

Ruby, 85 Bytes

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

Turned out fine, but there's probably a shorter solution.

Fast Fibonnaci calculation taken from here: link

Test it here


1

Julia, 36 bytes

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

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

{}

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

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



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

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.