Tanım

F(n)Pozitif tamsayılar üzerinde Fibonacci dizisi şöyle tanımlanır:

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

Pozitif bir tamsayı Fibonacci-orial ürünüdür [F(1), F(2), ..., F(n)].

Görev

Pozitif tamsayı verildiğinde n, Fibonacci-orial ofini bulun n.

gözlük

Fibonacci-orial, 100makul bir bilgisayarda 5 saniyeden kısa sürede hesaplanmalıdır.

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

Referanslar

• Zorunlu OEIS A003266
• OEIS A000045 - Fibonacci dizisi

Mathematica, 10 bayt

Fibonorial

Yerleşik başka bir Mathematica, yerleşik olmayan bir golf dili tarafından sesle dövüldü.

Jöle , 6 bayt

+С1ḊP

Giriş 100 yerel olarak 500 msn'de bitiyor. Çevrimiçi deneyin!

Nasıl çalışır

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

Aslında , 4 bayt

Giriş 100'ü 0,2 saniye içinde çalıştırır. Kod:

R♂Fπ

Açıklama:

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

CP-437 kodlamasını kullanır . Çevrimiçi deneyin! .

Brainfuck, 1198 1067 817 770 741 657 611 603

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

Sıkıştırılmamış, yorumlarla:

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

Çevrimiçi deneyin!

N = 100 için çalışma süresi çevrimiçi tercümanla (saniyede kendi tercümanımı kullanarak yerel olarak yaklaşık 0.2s) 1 saniyeden az. Maksimum giriş 255'tir, ancak tercümanın ~ 54000 hücreyi desteklemesini gerektirir (çevrimiçi tercüman 64k'yi gösteriyor gibi görünmektedir).

Günlüğü Değiştir

Geçerli sayının daha iyi çıkarımı ile çoğalması ve ekleme ve birleştirerek tek bir geçişte bir araya getirilmesiyle yaklaşık 130 bayt kurtarıldı. Aynı zamanda biraz daha hızlı gibi görünüyor.

250 bayt daha kaydedildi. Çarpım kazıma pedimi iki hücre düşürmeyi başardım, bu sayede haneler arasında dolaşmak zorunda kalmadan hemen hemen her yerde bayt tasarrufu sağladı. Ayrıca bir sayı ile çarptıktan sonra hamleyi düşürdüm ve bunun yerine koşu toplamına eklerken tam bir hamle yaptım.

Bir kez daha 50'yi, şimdiki basamağın daha iyi çıkarılmasıyla, sadece ilk yinelemeyi ilerletmeyerek ve bulunduğu yerden çalışarak çarparak daha fazla keserek doğrayın. Birkaç mikro optimizasyon daha aşağı yukarı ~ 10 baytlık bir değere sahiptir.

30 tane daha gitti. Zaten 1 yerine 0 ile alınmış basamakları bulmak daha kolay bulunmasını sağlar. Ayrıca, çarpma döngüsünün biraz daha basit bitip bitmediğini kontrol eder.

Scratch pad'i 80 hücre daha, başka bir hücre için azalttım. Bunu, önceki ürüne ait işaretçiyi ve mevcut toplamı birleştirerek, boşluklar arasındaki kaymaları azaltan ve defter tutmayı biraz daha kolaylaştırarak yaptım.

Başka bir hücreyi elimine ederek 50 tane daha kaydetti, en son alınan rakamı işaretlemek için fibonacci rakamları için işaretleyiciyi yeniden kullanın. Ayrıca, önceki toplamları rakamsal çarpma döngüsü ile kaydırmak için döngüyü birleştirebildim.

Giriş ayrıştırmada 8 bayt kaydedildi. Hata.

Python, 45 Bayt

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

Giriş stdin'den alınmıştır. N = 100 çıktısı doğru zaman için çok hızlı biter. n = 1000 yaklaşık 1 saniye sürer.

Örnek Kullanım

$ echo 10 | python fib-orial.py
122522400

$ echo 100 | python fib-orial.py
3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000

Haskell 41 29 Bayt

@ Laikoni'nin yorumlarıyla kaydedilen 1 + 11 bayt.

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

1, fVe !!ayrı simge vardır. İlk çizgiler fibonacci dizisini tanımlar, ikincisi fibonacci-orials dizisini hesaplayan ve belirli bir n için n. N = 1000 için bile hemen hemen basamak basmaya başlar.

Python 2,39 bayt

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

İdeone üzerinde test et .

J, 17 16 bayt

1 bayt, millerce daha da iyi bir çözüm ile golf oynamaktadır.

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

Bu fikir orijinal ile aynıdır, ancak küçük köşegenler üzerinde çalışacak matrisi oluşturmak yerine, köşegenler üzerinde köşegenler oluştururuz.

orijinal

İlk n fibonomiyi elde etmek için :

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

Sağdan sola okuma ... Belirtilene kadar
ardışık tamsayı i.dizisini oluşturun, bu diziden dizideki her çiftten hesaplanan /~binom katsayılarının ( !) tablosunu ( ) oluşturun , bu tablo Pascal'ın çemberin üstüdür. ilk satırın sonu ve ana köşegen altındaki tüm elemanlar 0'dır !. Eğer (toplarsak +/) Tüm minör çapraz mesafelerinin ( /.) kullanarak, Fibonacci sayılarını almak, ancak (almak gerekir {.uzunluğu (aynı sonuç dizisinden ilk elementlerin kadar) #masanın kendisinin). Daha sonra dizinin */ardışık öneklerine ( ) uygulanan ürün ( ) \, arzu edilen fibonorial dizisine yol açar.İsterseniz sadece 2 tane daha bayt ( {:) kullanarak sonuncuyu da alabilirsiniz. Fakat hepsini göstermenin günah olmadığını düşündüm :).
NB. the previous code block is not a J function.

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

J'deki büyük sayılar xiçin sonunda kullanabilirsiniz :

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

Program ortalama 0.11s ile çalışır .

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

Pyth, 13 bayt

u*Gs=[sZhZ)Q1

gösteri

Bu akıllıca, güvenli olmayan bir numara kullanır. ( u*G ... Q1) Karakterlerinden beşi , çıkışın birçok sayının girişinin ürünü olduğunu söyler. Kodun geri kalanı sayıları oluşturur.

=[sZhZ)değişkeni Zlisteye günceller [s(Z), h(Z)]. Ardından s, çarpılacak olan listeyi toplar.

Zbaşlangıçta 0'dır s, inç cinsinden kimlik işlevidir. h, onun üzerinde, + 1işlevdir. Böylece ilk tekrarda, Zolur [0, 1]. slistelerde yukarıda bahsedildiği gibi toplam işlevi bulunur. hkafa işlevidir. Yani ikinci yineleme [1, 0].

İşte bir liste:

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

Bu toplamlar sonucu vermek için çarpılır.

Mathematica 25 24 bayt

Martin Ender'e teşekkürler.

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

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

Zamanlama: 63 mikrosaniye.

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

Jöle, 8 bayt

RḶUc$S€P

Jelly’e ilk gönderim. @Dennis'in cevabı kadar kısa değil , ancak farklı bir yöntemle sadece 2 bayt daha uzun.

Yerel olarak, @Dennis 'sürümüyle 380ms'e kıyasla yaklaşık 400ms gerektirir. n = 100 .

Çevrimiçi deneyin!

açıklama

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 bayt

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

Veya alternatif olarak:

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

R, 99 96 78 76 66 bayt

Bu cevap, Binet Formülünü ve prod(x)fonksiyonunu kullanır. Yana R bir yap-sahip değil Phideğeri, kendim tanımlamıştır:

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

5 saniyenin altında çalışır, ancak R vermek eğilimindedir Infbu büyük sayılar için cevap olarak ...

Ungolfed:

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

@Cyoce sayesinde -2 bayt!
Bu siteyi seviyorum mu? @ User5957401 sayesinde -10 bayt

R, 82 , 53 , 49 bayt (farklı giriş stili ile 48 bayt)

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

Girilen kodla kodun hemen önüne geçebilirsek, 48 byte'ı alırız.

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

EDIT: Yeni kod. Orijinal aşağıda:

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)Yine de Inf dışında hiçbir şey geri dönmeyecek . Ve negatif olmayan tamsayılar dışında hiçbir şey için işe yaramaz.

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 bayt

golfed:

BigInteger f(int n){BigInteger[]a={BigInteger.ZERO,BigInteger.ONE,BigInteger.ONE};for(int i=0;i<n;){a[++i%2]=a[0].add(a[1]);a[2]=a[2].multiply(a[i%2]);}return a[2];}

Bu, BigIntegerçok sayıda olması nedeniyle gerekli olan başka bir durumdur . Bununla birlikte, metni BigIntegeren aza indirgeyerek, metni en aza indirmeyi başardım . Ayrıca statik ithalat ile karşılaştırdım ve toplam uzunluğu daha uzun yaptı.

Bu program bir dizideki üç sayıyı izleyerek çalışır. İlk iki önceki iki Fibonacci sayılarıdır. Üçüncüsü, biriken değerdir. Döngü bir sonraki değeri hesaplayarak ve değişken (0, 1, 0, 1, ...) dizi indekslerinde saklayarak başlar. Bu, değerleri (kaynak boyutuna göre) atama işlemleriyle pahalıya kaydırmaya gerek kalmamasıdır. Ardından bu yeni değeri alın ve akümülatör ile çarpın.

Geçici nesnelerden kaçınarak ve döngüyü iki atama operatörüyle sınırlandırarak birkaç bayt sıkmayı başardım.

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

}

Program çıktısı:

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 bayt

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

Çevrimiçi deneyin!

Ruby, 39 bayt

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

Javascript (ES6), 51 39 bayt

Özyinelemeli uygulama (39 bayt)

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

Orijinal uygulama (51 bayt)

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

Not: 16, 100 Fibonacci-orial için yuvarlama hatalarını başlatır, sadece Infinity, <1 saniye gibi göründüğü şekilde çalışır.

DC (GNU veya OpenBSD lezzet) , 36 bayt

Dosya A003266-v2.dc:

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

(takip eden yeni satır yok)

... şimdi sonuç, adlandırılmış bir kayıt kullanmak yerine yığında tutulur ( Ysürüm 1’de). rKomut orijinal mevcut değildir dc(bkz RosettaCode en DC sayfasını ).

Çalıştırmak:

$ 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

Açıklamaya çalışıyorum:

tosYığının tepesinin içeriği, çıkarmadandır.
nosaşağıdaki öğedir 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 bayt

... dümdüz, hile yok:

Dosya A003266-v1.dc:

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

(takip eden yeni satır yok)

Çalıştırmak:

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

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

açıklama

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

İteratif Fib algoritması

Brain-Flak , 54 bayt

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

Çevrimiçi deneyin!

Brain-Flak'ta çarpma, büyük girdiler için uzun zaman alıyor. Sadece F çarparak ₁₀₀ F ₉₉ milyarlarca yıl alacak bir genel çarpma algoritması ile.

Neyse ki daha hızlı bir yol var. Genelleştirilmiş bir Fibonacci dizisi, ile başlayan (k, 0), normal dizilim ile aynı terimleri üretecektir k. Bu gözlemi kullanarak Brain-Flak, Fibonacci sayıları üretebildiği kadar kolay bir Fibonacci sayısıyla çarpabilir.

Yığın -niki sayıdan oluşuyorsa , genelleştirilmiş Fibonacci dizisinin yinelemelerini {({}()<([({})]({}{}))>)}{}{}hesaplar nve sonuncusu atılır. Programın geri kalanı sadece ilk 1'i ayarlar ve aralıktaki tüm sayılar için bu döngüyü başlatır n...1.

İşte bu tercüman tarafından sağlanan diğer dillerde aynı algoritma:

Brain-Flak Classic, 52 bayt

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

Çevrimiçi deneyin!

Beyin-Baca, 58 bayt

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

Çevrimiçi deneyin!

Mini Flak, 62 bayt

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

Çevrimiçi deneyin!

Mathematica - 32 26 bayt

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

@ Martininder 6 byte doğranmış!

GAP 28 Bayt

Bugünden önce GAP'ın bir Fibonacciyerleşimi olduğunu bilmiyordum .

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

Ruby, 85 Bayt

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

İyi sonuçlandı, ancak muhtemelen daha kısa bir çözüm var.

Buradan alınan hızlı Fibonnaci hesaplaması: link

Burada test et

Julia, 36 bayt

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

Brain-Flak , 110 104 100 bayt

Çevrimiçi deneyin!

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

açıklama

İlk önce Dr Green Eggs ve Iron Man’in Fibonacci dizi üreteci perdesinin geliştirilmiş bir versiyonunu çalıştırdık.

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

Sonra yığında birden fazla öğe varken

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

ilk iki öğeyi çarp

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

ve ekstra sıfırı patla

{}

Clojure, 70 bayt

Clojure kod golf için gerçekten iyi bir dil değil. Oh iyi.

Http://tryclj.com adresinde deneyin .

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

İleri, 55 bayt

Forth'daki Fibonacci cevabım üzerine inşa edilmiş yinelemeli bir yaklaşım kullanır . Sonuçlar aritmetik olarak taşmıştır n > 10. Cevap büyük / küçük harf duyarlı değildir.

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

Çevrimiçi deneyin

Swift, 68 Bayt

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 bayt

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

Özyineleme ve akümülatör değişkenlerini kullanır. Yuvarlama hataları başlıyor f(16).