คำนิยาม

ลำดับ Fibonacci F(n)บนจำนวนเต็มบวกถูกกำหนดดังนี้:

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

ฟีโบนักชี-Orial [F(1), F(2), ..., F(n)]ของจำนวนเต็มบวกเป็นผลิตภัณฑ์ของ

งาน

ได้รับจำนวนเต็มบวกnหา Fibonacci-Orial nของ

รายละเอียด

fibonacci-orial ของ100ต้องคำนวณภายใน 5 วินาทีบนคอมพิวเตอร์ที่เหมาะสม

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

อ้างอิง

• ข้อผูกมัด OEIS A003266
• OEIS A000045 - ลำดับ Fibonacci

Mathematica ขนาด 10 ไบต์

Fibonorial

Mathematica อีกตัวที่ถูกทุบตีโดยใช้ภาษากอล์ฟโดยไม่มีเสียงในตัว

เยลลี่ 6 ไบต์

+С1ḊP

ป้อนข้อมูล 100 เสร็จสิ้นใน 500 ms ในพื้นที่ ลองออนไลน์!

มันทำงานอย่างไร

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

จริงแล้ว 4 ไบต์

รันอินพุต 100 ภายใน 0.2 วินาที รหัส:

R♂Fπ

คำอธิบาย:

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

ใช้การเข้ารหัสCP-437 ลองออนไลน์! .

Brainfuck, 1198 1067 817 770 741 657 611 603

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

ไม่ถูกบีบอัดพร้อมความคิดเห็น:

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

ลองออนไลน์!

รันไทม์สำหรับn = 100น้อยกว่า 1 วินาทีด้วยล่ามออนไลน์ (ประมาณ 0.2 วินาทีในพื้นที่โดยใช้ล่ามของฉันเอง) อินพุตสูงสุดคือ 255 แต่จะต้องการล่ามเพื่อรองรับ ~ 54000 เซลล์ (ล่ามออนไลน์ดูเหมือนจะพันบน 64k)

เปลี่ยนบันทึก

บันทึกไว้ประมาณ 130 ไบต์ด้วยการแยกตัวเลขปัจจุบันที่ดีกว่าเพื่อทวีคูณด้วยและโดยการรวมการเพิ่มและการดำเนินการในการส่งผ่านครั้งเดียว ดูเหมือนว่าจะเร็วขึ้นอีกเล็กน้อย

บันทึกอีก 250 ไบต์ ฉันจัดการเพื่อลดแผ่นรอยขีดข่วนการคูณของฉันโดยสองเซลล์ซึ่งบันทึกไบต์ได้ทุกที่โดยไม่ต้องเลื่อนไปมาระหว่างตัวเลข ฉันยังลดการพกพาหลังจากคูณด้วยหลักและทำการแสดงแบบเต็มขณะที่เพิ่มผลรวมการวิ่ง

สับอีก 50 ครั้งอีกครั้งด้วยการแยกตัวเลขปัจจุบันที่ดีกว่าเพื่อคูณด้วยเพียงแค่ไม่เลื่อนไปข้างหน้าการทำซ้ำครั้งแรกและทำงานจากที่ที่มันอยู่ การเพิ่มประสิทธิภาพเล็ก ๆ น้อย ๆ เพิ่มเติมบัญชีประมาณประมาณ 10 ไบต์

หายไป 30 รายการ การทำเครื่องหมายตัวเลขที่มีเครื่องหมายเป็น 0 แทนที่จะเป็น 1 ทำให้ง่ายต่อการค้นหา นอกจากนี้ยังทำให้การตรวจสอบว่าการวนซ้ำการวนได้ค่อนข้างง่าย

ฉันลดแผ่นรอยขีดข่วนโดยเซลล์อื่นสำหรับอีก 80 ไบต์ ฉันทำสิ่งนี้ด้วยการรวมเครื่องหมายสำหรับผลิตภัณฑ์ก่อนหน้าและผลรวมการรันปัจจุบันซึ่งช่วยลดการเลื่อนระหว่างช่องว่างและทำให้การทำบัญชีง่ายขึ้นเล็กน้อย

บันทึกอีก 50 ด้วยการกำจัดเซลล์อื่นนำเครื่องหมายมาใช้สำหรับตัวเลขฟีโบนักชีเพื่อทำเครื่องหมายตัวเลขสุดท้ายที่ถ่ายด้วย ฉันยังสามารถรวมลูปเพื่อเปลี่ยนผลรวมก่อนหน้าด้วยลูปการคูณด้วยตัวเลขที่ชาญฉลาด

บันทึก 8 ไบต์เมื่อแยกวิเคราะห์อินพุต อุ่ย

Python ขนาด 45 ไบต์

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

อินพุตถูกนำมาจาก stdin เอาต์พุตสำหรับn = 100เสร็จเร็วเกินไปที่จะกำหนดเวลาอย่างแม่นยำ n = 1,000ใช้เวลาประมาณ 1 วินาที

ตัวอย่างการใช้งาน

$ echo 10 | python fib-orial.py
122522400

$ echo 100 | python fib-orial.py
3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000

Haskell 41 29 Bytes

1 + 11 ไบต์บันทึกโดยคำพูดของ @ Laikoni

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

1, fและ!!เป็นราชสกุลแยกต่างหาก บรรทัดแรกกำหนดลำดับฟีโบนักชีส่วนที่สองเป็นฟังก์ชันที่คำนวณลำดับฟีโบนักชีและส่งคืนค่า n-th สำหรับเอ็นที่กำหนด มันเริ่มพิมพ์ตัวเลขเกือบจะทันทีแม้กระทั่งสำหรับ n = 1,000

Python 2, 39 ไบต์

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

ทดสอบบนIdeone

J, 17 16 ไบต์

1 ไบต์ถูกตีกอล์ฟด้วยวิธีแก้ปัญหาที่ดีกว่าหลายไมล์

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

ความคิดนั้นเหมือนกับต้นฉบับ แต่แทนที่จะสร้างเมทริกซ์เพื่อทำงานบน diagonals เล็ก ๆ น้อย ๆ เราสร้าง diagonals ขึ้นมาทันที

เป็นต้นฉบับ

ในการรับค่าn Fibonomials แรก:

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

อ่านจากขวาไปซ้าย ...
สร้างอาร์เรย์ของจำนวนเต็มต่อเนื่อง ( i.) สูงสุดที่ระบุจากอาร์เรย์นั้นสร้างตาราง ( /~) ของสัมประสิทธิ์ทวินาม ( !) คำนวณจากทุกคู่ในอาร์เรย์ตารางนี้คือด้านบนรูปสามเหลี่ยมของปาสกาลที่ ในตอนท้ายของแถวแรกและองค์ประกอบทั้งหมดภายใต้เส้นทแยงมุมหลักคือ 0, !โชคดีกับการดำเนินการ หากคุณรวม ( +/) diagonals เล็กน้อยทั้งหมด ( /.) คุณจะได้รับหมายเลขฟีโบนักชี แต่คุณต้องรับ ( {.) อิลิเมนต์แรกจากอาร์เรย์ผลลัพธ์เป็นความยาว ( #) ของตารางเอง จากนั้นผลิตภัณฑ์ ( */) นำไปใช้กับคำนำหน้าติดต่อกัน ( \) ของอาร์เรย์ผลลัพธ์เป็นลำดับที่ต้องการของ fibonorialsถ้าคุณต้องการคุณสามารถใช้เวลาเพียงคนสุดท้ายใช้ 2 ไบต์ ( {:) :)แต่ผมคิดว่าการแสดงทั้งหมดของพวกเขาไม่ได้เป็นบาป
NB. the previous code block is not a J function.

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

สำหรับตัวเลขขนาดใหญ่ใน J คุณใช้xในตอนท้าย:

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

โปรแกรมวิ่งบน avarage 0.11s

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

Pyth, 13 ไบต์

u*Gs=[sZhZ)Q1

สาธิต

วิธีนี้ใช้เคล็ดลับที่ฉลาดและไม่ปลอดภัย ห้าตัวอักษร ( u*G ... Q1) บอกว่าผลผลิตเป็นผลผลิตของตัวเลขจำนวนมาก ส่วนที่เหลือของรหัสสร้างตัวเลข

=[sZhZ)ปรับปรุงตัวแปรในรายการZ [s(Z), h(Z)]จากนั้นsสรุปรายการนั้น ๆ เพื่อคูณ

Zคือ 0 เริ่มแรกsบน ints คือฟังก์ชันตัวตน hในนั้นเป็น+ 1ฟังก์ชั่น ดังนั้นในการย้ำแรกจะกลายเป็นZ ในรายการเป็นฟังก์ชั่นผลรวมดังกล่าวข้างต้น[0, 1]shเป็นฟังก์ชั่นหัว [1, 0]ดังนั้นซ้ำสองคือ

นี่คือรายการ:

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

จำนวนเงินเหล่านี้จะถูกนำมาคูณกันเพื่อให้ผลลัพธ์

Mathematica 25 24 ไบต์

ด้วยความขอบคุณ Martin Ender

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

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

เวลา: 63 ไมโครวินาที

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

เยลลี่ขนาด 8 ไบต์

RḶUc$S€P

การส่งครั้งแรกของฉันในเยลลี่ มันไม่สั้นเท่ากับคำตอบของ @Dennis แต่มีความยาวเพียง 2 ไบต์เท่านั้นและมีวิธีการต่างกัน

ในพื้นที่มันต้องใช้เวลาประมาณ 400ms เทียบกับ 380ms ด้วย @Dennis 'version สำหรับn = 100

ลองออนไลน์!

คำอธิบาย

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

PARI / GP, 29 ไบต์

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

หรืออีกทางหนึ่ง:

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

R, 99 96 78 76 66 ไบต์

คำตอบนี้ใช้สูตรของ Binetรวมถึงprod(x)ฟังก์ชั่น เนื่องจากRไม่มีPhiค่าบิลด์อินฉันจึงกำหนดด้วยตนเอง:

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

มันใช้งานได้ต่ำกว่า 5 วินาที แต่Rมีแนวโน้มที่จะให้Infคำตอบสำหรับตัวเลขขนาดใหญ่เหล่านั้น ...

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ไบต์ขอบคุณ @Cyoce!
โอ้ฉันรักเว็บไซต์นี้ไหม! -10ไบต์ขอบคุณ @ user5957401

R, 82 , 53 , 49 ไบต์ (48 ไบต์พร้อมรูปแบบการป้อนข้อมูลที่แตกต่างกัน)

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

ถ้าเราสามารถนำหน้ารหัสด้วยหมายเลขอินพุตเราจะได้ 48 ไบต์

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

แก้ไข:รหัสใหม่ ต้นฉบับอยู่ด้านล่าง:

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

จะไม่กลับอะไรอื่นนอกจาก Inf สำหรับa(100)แม้ว่า และมันจะไม่ทำงานอะไรเลยยกเว้นจำนวนเต็มไม่เป็นลบ

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

Java, 165 ไบต์

แข็งแรงเล่นกอล์ฟ:

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

นี่เป็นอีกกรณีที่BigIntegerจำเป็นเนื่องจากมีจำนวนมาก อย่างไรก็ตามฉันสามารถทำให้ข้อความBigIntegerน้อยที่สุดทำให้ขนาดลดลง ฉันเปรียบเทียบกับการนำเข้าแบบสแตติกและทำให้ความยาวทั้งหมดยาวขึ้น

โปรแกรมนี้ทำงานโดยติดตามตัวเลขสามตัวในอาเรย์ สองคนแรกเป็นตัวเลขสองหมายเลขก่อนหน้าของฟีโบนักชี ที่สามคือมูลค่าสะสม การวนซ้ำเริ่มต้นด้วยการคำนวณค่าถัดไปและเก็บไว้ในดัชนีอาร์เรย์ (0, 1, 0, 1, ... ) วิธีนี้จะช่วยหลีกเลี่ยงไม่ให้ต้องเลื่อนค่าด้วยการดำเนินการกำหนดค่าใช้จ่าย (ในแง่ของขนาดแหล่งที่มา) จากนั้นหยิบค่าใหม่นั้นแล้วนำไปคูณกับตัวสะสม

โดยการหลีกเลี่ยงวัตถุชั่วคราวและ จำกัด การวนรอบให้กับตัวดำเนินการกำหนดค่าสองตัวฉันสามารถบีบออกได้สองสามไบต์

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

}

ผลลัพธ์ของโปรแกรม:

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

Brachylogขนาด 31 ไบต์

,[1:0]:?:{hH,?bh:H+g:?c.}irbb*.

ลองออนไลน์!

Ruby, 39 ไบต์

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

Javascript (ES6), 51 39 ไบต์

การใช้งานแบบเรียกซ้ำ (39 ไบต์)

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

การใช้งานดั้งเดิม (51 ไบต์)

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

หมายเหตุ: เริ่มการปัดเศษข้อผิดพลาดสำหรับ Fibonacci-orial ที่ 16, 100 เป็นแค่ Infinity เรียกใช้ในสิ่งที่ดูเหมือนว่า <1 วินาที

DC (รส GNU หรือ OpenBSD)ขนาด 36 ไบต์

ไฟล์A003266-v2.dc:

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

(ไม่ขึ้นบรรทัดใหม่)

... ตอนนี้ผลลัพธ์ถูกเก็บไว้ในสแต็กแทนที่จะใช้การลงทะเบียนที่มีชื่อ (อยู่Yในเวอร์ชัน 1) rคำสั่งไม่สามารถใช้ได้ในต้นฉบับdc(ดูหน้า Dc RosettaCode ของ )

วิ่ง:

$ 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

พยายามอธิบาย:

tosคือเนื้อหาของด้านบนสุดของสแต็กโดยไม่ลบออก เป็นองค์ประกอบดังต่อไปนี้
nostos

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 ไบต์

... ตรงไปข้างหน้าไม่มีเทคนิค:

ไฟล์A003266-v1.dc:

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

(ไม่ขึ้นบรรทัดใหม่)

วิ่ง:

$ 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

C # 110 109 107 103 101 94 ไบต์

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

คำอธิบาย

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

อัลกอริทึม Fibre ซ้ำ

Brain-Flakขนาด 54 ไบต์

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

ลองออนไลน์!

การคูณใน Brain-Flak ใช้เวลานานสำหรับอินพุตขนาดใหญ่ เพียงแค่คูณ F ₁₀₀ด้วย F ₉₉ด้วยอัลกอริทึมการคูณทั่วไปจะใช้เวลาหลายพันล้านปี

โชคดีที่มีวิธีที่เร็วกว่า ลำดับฟีโบนักชีทั่วไปที่เริ่มต้นด้วย(k, 0)kจะสร้างเงื่อนไขเช่นเดียวกับลำดับปกติคูณด้วย เมื่อใช้การสังเกตนี้ Brain-Flak สามารถคูณด้วยหมายเลขฟีโบนักชีได้อย่างง่ายดายเหมือนกับที่มันสามารถสร้างตัวเลขฟีโบนักชี

หากสแต็กประกอบด้วย-nตามด้วยตัวเลขสองตัว{({}()<([({})]({}{}))>)}{}{}จะคำนวณnการวนซ้ำของลำดับฟีโบนักชีทั่วไปและยกเลิกทั้งหมดในที่สุด ส่วนที่เหลือของโปรแกรมเพิ่งตั้งค่าเริ่มต้น 1 และวนn...1ซ้ำผ่านสิ่งนี้สำหรับตัวเลขทั้งหมดในช่วง

นี่คืออัลกอริทึมเดียวกันในภาษาอื่น ๆ ที่มีให้โดยล่ามนี้:

Brain-Flak Classic, 52 ไบต์

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

ลองออนไลน์!

Brain-Flueue ขนาด 58 ไบต์

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

ลองออนไลน์!

Mini-Flak ขนาด 62 ไบต์

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

ลองออนไลน์!

Mathematica - 32 26 ไบต์

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

@MartinEnder สับ 6 ไบต์!

GAP 28 ไบต์

ไม่ทราบมาก่อนวันนี้ว่า GAP มีแบบFibonacciบิลท์อิน

n->Product([1..n],Fibonacci)

Ruby, 85 ไบต์

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

กลายเป็นดี แต่อาจมีวิธีแก้ปัญหาที่สั้นกว่า

การคำนวณ Fibonnaci อย่างรวดเร็วนำมาจากที่นี่: ลิงก์

ทดสอบที่นี่

Julia, 36 ไบต์

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

Brain-Flak , 110 104 100 ไบต์

ลองออนไลน์!

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

คำอธิบาย

ก่อนอื่นเราเรียกใช้ Fibonacci Sequential Generator รุ่นที่ปรับปรุงแล้วของDr Green Eggs และ Iron Man

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

จากนั้นในขณะที่สแต็กมีมากกว่าหนึ่งรายการในนั้น

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

คูณสองรายการแรกสุด

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

และป๊อปศูนย์พิเศษ

{}

Clojure 70 ไบต์

Clojure ไม่ใช่ภาษาที่ดีสำหรับการตีกอล์ฟ โอ้ดี

ลองมันที่http://tryclj.com

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

มา, 55 ไบต์

ใช้วิธีการวนซ้ำสร้างขึ้นตามคำตอบ Fibonacci ของฉันใน Forth ผลล้น arithmetically n > 10สำหรับ คำตอบนั้นไม่ตรงตามตัวพิมพ์ใหญ่ - เล็ก

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

ลองออนไลน์

Swift, 68 Bytes

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

JavaScript (ES6), 46 ไบต์

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

ใช้การเรียกซ้ำและตัวแปรตัวสะสม f(16)ข้อผิดพลาดปัดเศษเริ่มต้นที่