Định nghĩa

Chuỗi Fibonacci F(n), trên các số nguyên dương, được định nghĩa như sau:

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

Fib-orial của một số nguyên dương là sản phẩm của [F(1), F(2), ..., F(n)].

Bài tập

Cho số nguyên dương n, tìm số nguyên gốc của n.

Thông số kỹ thuật

Các orialial 100phải tính toán dưới 5 giây trên một máy tính hợp lý.

Tủ thử

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

Tài liệu tham khảo

• Bắt buộc OEIS A003266
• OEIS A000045 - Chuỗi Fibonacci

Toán học, 10 byte

Fibonorial

Một Mathicala tích hợp sẵn bị đánh bại bởi một ngôn ngữ chơi gôn mà không có tích hợp.

Thạch , 6 byte

+С1ḊP

Nhập 100 kết thúc trong 500 ms cục bộ. Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Thực ra , 4 byte

Chạy 100 đầu vào trong vòng 0,2 giây. Mã số:

R♂Fπ

Giải trình:

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

Sử dụng mã hóa CP-437 . Hãy thử trực tuyến! .

Brainfuck, 1198 1067 817 770 741 657 611 603

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

Không nén, với ý kiến:

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

Hãy thử trực tuyến!

Thời gian chạy cho n = 100 là ít hơn 1 giây với trình thông dịch trực tuyến (khoảng 0,2 giây cục bộ sử dụng trình thông dịch của riêng tôi). Đầu vào tối đa là 255, nhưng sẽ yêu cầu trình thông dịch hỗ trợ ~ 54000 ô (trình thông dịch trực tuyến dường như có giá trị 64k).

Thay đổi nhật ký

Đã lưu khoảng 130 byte với việc trích xuất tốt hơn chữ số hiện tại để nhân lên và bằng cách hợp nhất thêm và mang vào một lượt. Nó dường như cũng nhanh hơn một chút.

Đã lưu 250 byte khác. Tôi đã quản lý để giảm số lần cào nhân của mình xuống hai ô, giúp tiết kiệm byte ở mọi nơi bằng cách không phải thay đổi giữa các chữ số. Tôi cũng bỏ việc mang theo sau khi nhân với một chữ số, và thay vào đó thực hiện việc mang theo đầy đủ trong khi thêm vào tổng số đang chạy.

Cắt thêm 50, một lần nữa với việc trích xuất tốt hơn chữ số hiện tại để nhân lên, đơn giản bằng cách không di chuyển nó về phía trước của lần lặp đầu tiên và làm việc từ vị trí của nó. Một vài tối ưu hóa vi mô tiếp tục chiếm khoảng ~ 10 byte.

Thêm 30 nữa. Đánh dấu các chữ số đã được thực hiện bằng 0 thay vì 1 giúp chúng dễ dàng xác định vị trí hơn. Nó cũng làm cho việc kiểm tra nếu vòng lặp nhân đã hoàn thành có phần đơn giản hơn.

Tôi đã giảm phần đệm bằng một ô khác, để có thêm 80 byte. Tôi đã làm điều này bằng cách hợp nhất điểm đánh dấu cho sản phẩm trước đó và tổng số hoạt động hiện tại, điều này làm giảm sự thay đổi giữa các khoảng trống và làm cho việc ghi sổ dễ dàng hơn một chút.

Đã lưu thêm 50, bằng cách loại bỏ một ô khác, sử dụng lại điểm đánh dấu cho các chữ số của Wikipedia để đánh dấu chữ số cuối cùng được thực hiện. Tôi cũng có thể hợp nhất vòng lặp để thay đổi tổng số trước đó với vòng nhân số có chữ số.

Đã lưu 8 byte khi phân tích cú pháp đầu vào. Rất tiếc.

Python, 45 byte

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

Đầu vào được lấy từ stdin. Đầu ra cho n = 100 kết thúc quá nhanh đến thời gian chính xác. n = 1000 mất khoảng 1 giây.

Sử dụng mẫu

$ echo 10 | python fib-orial.py
122522400

$ echo 100 | python fib-orial.py
3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000

Haskell 41 29 byte

1 + 11 byte được lưu bởi nhận xét của @ Laikoni.

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

1, fVà !!là thẻ riêng biệt. Các dòng đầu tiên xác định chuỗi của Wikipedia, dòng thứ hai là một hàm tính toán chuỗi các orials và trả về n-th cho một n đã cho. Nó bắt đầu in các chữ số gần như ngay lập tức ngay cả với n = 1000.

Python 2, 39 byte

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

Kiểm tra nó trên Ideone .

J, 17 16 byte

1 byte được golfed với giải pháp tốt hơn bằng cách dặm.

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

Ý tưởng giống như bản gốc nhưng thay vì hình thành ma trận để hoạt động trên các đường chéo nhỏ, chúng ta tạo thành các đường chéo khi đang bay.

Nguyên

Để có được n nguyên bào sợi đầu tiên :

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

Đọc từ phải sang trái ...
Tạo mảng các số nguyên liên tiếp ( i.) cho đến một số nguyên được chỉ định, từ mảng đó tạo bảng ( /~) các hệ số nhị thức ( !) được tính từ mỗi cặp trong mảng, bảng này là đỉnh tam giác của Pascal được đặt tại kết thúc của hàng đầu tiên và tất cả các yếu tố dưới đường chéo chính là 0, rất may để thực hiện !. Nếu bạn tính tổng ( +/) tất cả các đường chéo nhỏ ( /.), bạn sẽ nhận được các số Fibonacci, nhưng bạn cần lấy ( {.) nhiều phần tử đầu tiên từ mảng kết quả bằng độ dài ( #) của chính bảng. Sau đó, sản phẩm ( */) được áp dụng cho các tiền tố liên tiếp ( \) của kết quả mảng thành chuỗi các chuỗi sợi mong muốn. Nếu bạn muốn bạn chỉ có thể lấy cái cuối cùng bằng cách sử dụng thêm 2 byte ( {:) nhưng tôi nghĩ rằng hiển thị tất cả chúng không phải là một tội lỗi :).
NB. the previous code block is not a J function.

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

Đối với số lớn trong J bạn sử dụng xở cuối:

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

Chương trình chạy trên avarage 0.11s .

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

Bình thường, 13 byte

u*Gs=[sZhZ)Q1

Trình diễn

Điều này sử dụng một thủ thuật thông minh, không an toàn. Năm trong số các nhân vật (u*G ... Q1 ) nói rằng đầu ra là tích của nhiều số đầu vào. Phần còn lại của mã tạo ra các số.

=[sZhZ)cập nhật biến Zvào danh sách [s(Z), h(Z)]. Sau đó stổng hợp danh sách đó, để được nhân lên.

Zban đầu là 0. s, trên ints, là hàm nhận dạng. h, trên đó, là + 1chức năng. Vì vậy, trên lần lặp đầu tiên, Ztrở thành [0, 1]. strên danh sách là hàm tổng, như đã đề cập ở trên. hlà chức năng đầu. Vì vậy, lần lặp thứ hai là [1, 0].

Đây là danh sách:

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

Các khoản tiền này được nhân lên để đưa ra kết quả.

Toán học 25 24 byte

Cảm ơn Martin Ender.

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

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

Thời gian: 63 micro giây.

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

Thạch, 8 byte

RḶUc$S€P

Trình đầu tiên của tôi trong Jelly. Nó không ngắn như câu trả lời của @Dennis , nhưng nó chỉ dài hơn 2 byte với một phương thức khác.

Tại địa phương, nó cần khoảng 400ms so với 380ms với phiên bản @Dennis 'cho n = 100.

Hãy thử trực tuyến!

Giải trình

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 byte

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

Hay cách khác:

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

R, 99 96 78 76 66 byte

Câu trả lời này là sử dụng Công thức của Binet , cũng như prod(x)chức năng. Vì R không có Phigiá trị tích hợp, tôi tự xác định nó:

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

Nó hoạt động dưới 5 giây, nhưng R có xu hướng đưa ra Infcâu trả lời cho những con số lớn đó ...

Ung dung:

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 nhờ @Cyoce!
Oh, tôi có thích trang web này không! -10 byte nhờ @ user5957401

R, 82 , 53 , 49 byte (48 byte w / kiểu nhập khác nhau)

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

Nếu chúng ta chỉ có thể đặt trước mã với số đầu vào, chúng ta sẽ nhận được 48 byte

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

EDIT: Mã mới. Bản gốc là dưới đây:

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

a(100)Mặc dù không trả lại bất cứ thứ gì ngoài Inf . Và nó sẽ không hoạt động cho bất cứ điều gì ngoại trừ số nguyên không âm.

Ung dung:

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 byte

Chơi gôn

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

Đây là một trường hợp khác BigIntegerđược yêu cầu do số lượng lớn. Tuy nhiên, tôi đã có thể giữ văn bản BigIntegerở mức tối thiểu, giữ kích thước xuống. Tôi cũng so sánh với nhập khẩu tĩnh, và nó làm cho tổng chiều dài dài hơn.

Chương trình này hoạt động bằng cách theo dõi ba số trong một mảng. Hai số đầu tiên là hai số Fibonacci trước đó. Thứ ba là giá trị tích lũy. Vòng lặp bắt đầu bằng cách tính giá trị tiếp theo và lưu trữ nó trong các chỉ số mảng xen kẽ (0, 1, 0, 1, ...). Điều này tránh việc cần phải thay đổi giá trị với các hoạt động chuyển nhượng tốn kém (về kích thước nguồn). Sau đó lấy giá trị mới đó và nhân nó vào bộ tích lũy.

Bằng cách tránh các đối tượng tạm thời và giới hạn vòng lặp cho hai toán tử gán, tôi có thể thu được khá nhiều byte.

Ung dung:

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

}

Đầu ra chương trình:

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 byte

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

Hãy thử trực tuyến!

Ruby, 39 byte

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

Javascript (ES6), 51 39 byte

Thực hiện đệ quy (39 byte)

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

Triển khai ban đầu (51 byte)

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

Lưu ý: Bắt đầu các lỗi làm tròn cho Fib-orial 16, 100 chỉ là Vô cực, chạy trong khoảng thời gian có vẻ là <1 giây.

DC (hương vị GNU hoặc OpenBSD) , 36 byte

Tập tin A003266-v2.dc:

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

(không có dòng mới)

... bây giờ kết quả được giữ trên ngăn xếp thay vì sử dụng một thanh ghi có tên ( Ytrong phiên bản 1). Các rlệnh không có sẵn trong bản gốc dc(xem trang Dc RosettaCode của ).

Chạy:

$ 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

Cố gắng giải thích:

toslà nội dung của đỉnh ngăn xếp mà không loại bỏ nó.
noslà yếu tố dưới đây 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

... thẳng tiến, không thủ đoạn:

Tập tin A003266-v1.dc:

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

(không có dòng mới)

Chạy:

$ 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 byte

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

Giải trình

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

Thuật toán lặp lặp Fib

Brain-Flak , 54 byte

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

Hãy thử trực tuyến!

Phép nhân trong Brain-Flak mất nhiều thời gian cho các đầu vào lớn. Chỉ cần nhân F ₁₀₀ với F ₉₉ với thuật toán nhân chung sẽ mất hàng tỷ năm.

May mắn thay, có một cách nhanh hơn. Một chuỗi Fibonacci tổng quát bắt đầu bằng (k, 0)sẽ tạo ra các thuật ngữ giống như chuỗi thông thường, nhân với k. Sử dụng quan sát này, Brain-Flak có thể nhân với một số Fibonacci dễ dàng như nó có thể tạo ra các số Fibonacci.

Nếu ngăn xếp bao gồm -nhai số theo sau, {({}()<([({})]({}{}))>)}{}{}sẽ tính toán các nlần lặp của chuỗi Fibonacci tổng quát và loại bỏ tất cả các số cuối cùng. Phần còn lại của chương trình chỉ thiết lập 1 ban đầu và lặp qua điều này cho tất cả các số trong phạm vin...1 .

Đây là thuật toán tương tự trong các ngôn ngữ khác được cung cấp bởi trình thông dịch này:

Brain-Flak Classic, 52 byte

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

Hãy thử trực tuyến!

Brain-Flueue, 58 byte

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

Hãy thử trực tuyến!

Mini-Flak, 62 byte

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

Hãy thử trực tuyến!

Toán học - 32 26 byte

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

@MartinEnder băm nhỏ 6 byte!

GAP 28 byte

Hôm nay không biết rằng GAP có Fibonaccinội dung.

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

Ruby, 85 byte

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

Hóa ra tốt, nhưng có lẽ có một giải pháp ngắn hơn.

Tính toán nhanh Fibonnaci được lấy từ đây: link

Kiểm tra nó ở đây

Julia, 36 byte

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

Brain-Flak , 110 104 100 byte

Hãy thử trực tuyến!

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

Giải trình

Trước tiên, chúng tôi chạy phiên bản cải tiến của trình tạo chuỗi Fibonacci của Dr Green Eggs và Iron Man

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

Sau đó, trong khi ngăn xếp có nhiều hơn một mục trên đó

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

nhân hai mục hàng đầu

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

và bật thêm 0

{}

Clojure, 70 byte

Clojure không thực sự là một ngôn ngữ tốt cho môn đánh gôn. Ồ tốt

Hãy thử nó tại http://tryclj.com .

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

Forth, 55 byte

Sử dụng một cách tiếp cận lặp đi lặp lại, được xây dựng dựa trên câu trả lời Fibonacci của tôi trong Forth. Các kết quả tràn một cách hợp lý cho n > 10. Câu trả lời là không phân biệt chữ hoa chữ thường.

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

Dùng thử trực tuyến

Swift, 68 byte

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 byte

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

Sử dụng các biến đệ quy và tích lũy. Lỗi làm tròn bắt đầu từ f(16).