斐波那契


36

定义

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

正整数的斐波那契数是的乘积[F(1), F(2), ..., F(n)]

任务

给定正整数n,找到的斐波那契n

眼镜

100合理的计算机必须在5秒钟内计算出fibonacciorial 。

测试用例

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

参考文献



1
@LuisMendo斐波那契的总和是...你猜对了,斐波那契。好吧,减一。
Leaky Nun

2
@LeakyNun当前,JavaScript答案最多只能完成15个测试用例,因为JavaScript无法正确比较(或操作)2 ^ 53-1以上的数字。这在此处的许多提交中很可能相似,因为大多数语言都不会支持数字那么大
MayorMonty 2016年

1
“合理的计算机”是什么意思?
暴民埃里克

2
-1,因为这似乎是解决了几个挑战(范围,每个斐波那契,阶乘),而没有特别有趣的捷径。
硕果累累

Answers:


63

Mathematica,10个字节

Fibonorial

没有内置功能的情况下,另一个内置的Mathematica被高尔夫球语言打败了。


49
我……什么……为什么,Mathematica ?!
林恩

3
忘记该功能甚至存在!
LegionMammal978 '16

3
@Lynn 规则35:如果存在,则具有Mathematica函数;)
Beta Decay

9
@BetaDecay我以为我们已经确定它是规则110
马丁·恩德

1
不,规则110是非常不同的东西。尽管我确定Mathematica也具有内置功能。
AdmBorkBork,2016年

27

果冻,6 字节

+С1ḊP

输入100在本地500毫秒内完成。在线尝试!

怎么运行的

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

那么第n个斐波那契+¡1非内建非+С1斐波那契数是第一个吗?
caird coinheringaahing 17-10-11

@cairdcoinheringaahing差不多。
丹尼斯,

我以为有内置的斐波那契函数?
MilkyWay90


16

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个字节。哎呀。


14

Python,45字节

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

输入来自标准输入。n = 100的输出完成得太快而无法准确计时。n = 1000需要大约1s。

样品用量

$ echo 10 | python fib-orial.py
122522400

$ echo 100 | python fib-orial.py
3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000

13

Haskell 41 29字节

@Laikoni的言论节省了1 + 11个字节。

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

1f!!是独立的令牌。第一行定义斐波纳契序列,第二行是计算斐波纳契序列的函数,并针对给定的n返回第n个函数。即使n = 1000,它也几乎立即开始打印数字。


1
您可以摆脱空间(scanl(*)1f!!)
Laikoni '16

2
而且还有一个更短的斐波那契数发生器这里f=1:scanl(+)1f
Laikoni

@Laikoni太好了,谢谢!
Christian Sievers,2016年

2
@WillNess我认为我不仅因其他用户的行为而有道理,而且也因meta.codegolf.stackexchange.com/questions/2419/…meta.codegolf.stackexchange.com/questions/9031/…(但还有更多,而我还没有读完)
Christian Sievers

1
@flawr您是否可以接受42+添加42的函数?您不应该这样做,因为这只是一个未完成的表达。但是在Haskell中,我们可以添加括号并取得该部分 (42+),这是一种编写函数的方法\n->42+n。在这里是相同的,只是使用!!(用于索引的二进制中缀运算符)代替了,+并且使用了更复杂的第一个操作数。
Christian Sievers

11

Python 2,39个字节

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

Ideone上进行测试


您可能需要指定它True在某些情况下返回。
Leaky Nun

5
这只会True为输入0返回,这不是肯定的。
丹尼斯

6

J,17 16字节

1字节的距离可以达到更好的解决方案。

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

这个想法与最初的想法相同,但我们不是动态地形成对角线,而是形成用于对角线较小的矩阵。


原版的

要获得前n个斐波那命:

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

从右到左阅读...
创建连续整数(i.)直到指定整数的数组,从该数组创建从该数组中每一对计算出/~的二项式系数(!)的表(),该表是Pascal的三角形顶部,位于感谢实施,第一行的结尾以及主对角线下的所有元素均为0 !。如果将+/所有()次对角线(/.)相加(),则会得到斐波那契数,但您需要{.从结果数组中抽取()等于#表本身的长度()的第一元素。然后,将*/应用于\数组的连续前缀()的乘积()转换为所需的fibonorials序列。如果您愿意,只能使用另外2个字节{:来获取最后一个,但是我认为显示全部这些并不是罪过:)
NB. the previous code block is not a J function

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

对于J中的大数字,请x在末尾使用:

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

该程序平均运行0.11s

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

1
一种替代功能是[:*/+/@(!|.)\@i.使用16个字节。它沿生成的表形成相同的二项式系数,!/~只是它以开头为i.
英里

4

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]s如上所述,列表上的是求和函数。h是头部功能。因此,第二次迭代是[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

将这些总和相乘即可得出结果。


4

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}

或者,具有相同的字节数:1##&@@Fibonacci~Array~#&
Greg Martin

4

果冻,8 个字节

RḶUc$S€P

我在果冻中的第一次提交。它不如@Dennis的答案那么短,但是使用不同的方法时,它仅长2个字节。

在本地,它需要大约400毫秒,而@Dennis版本的n = 100 则需要380毫秒。

在线尝试!

说明

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个字节

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

或者:

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

3

R,99 96 78 76 66字节

这个答案是使用Binet的Formula以及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为这些大数字提供答案...

松散

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


可能可以通过存储sqrt(5)到变量来节省一点时间
Cyoce '16

由于您只使用N一次,因此只能1:N在位内调用scan 。即for(n in 1:scan())。您也可以只使用for循环中的*代替prod()函数来保存一些字符。您的for循环只有一行,因此您也不需要花括号。
user5957401

使用Binet公式的好主意。以您的精神,但只有53个字节是function(n,N=1:n,p=5^.5)prod(((1+p)^N-(1-p)^N)/2^N/p)
Michael M

3

R,8253,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)})

a(100)虽然不会返回Inf以外的任何内容。除非负整数外,它对其他任何功能均无效。

取消高尔夫:

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个字节

打高尔夫球:

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,...)数组索引中,循环开始。这避免了需要通过昂贵的(根据源大小)分配操作来移动值。然后获取该新值,并将其乘以累加器。

通过避免使用临时对象并将循环限制为两个赋值运算符,我可以挤出很多字节。

取消高尔夫:

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


2

Ruby,39个字节

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

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

2

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秒。


我制作了一个备用的53字节版本,n=>[...Array(n)].reduce(p=>(c=a,a=b,p*=b+=c),a=1,b=0)只是为了发现您已经将f=它计数了,不需要为您节省2个字节。
尼尔2016年

有道理。我的理由是,它是可以调用可重用的,而不仅仅是可以调用的。
Pandacoder '16

可以,但是如果有人确实想重用它,那么他们仍然可以选择命名。
尼尔

@Neil好了,现在我去重新实现了它,现在f =是强制性的,否则它实际上无法执行。:D
Pandacoder '16

好吧,至少您固定了原始实现的字节数。
尼尔

2

DC(GNU或OpenBSD风格),36字节

档案A003266-v2.dc

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

(无尾随换行符)

...现在结果保存在堆栈中,而不是使用命名寄存器(Y版本1)。该r命令在原始文件中不可用dc(请参见RosettaCode的Dc页面)。

跑:

$ 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是堆栈顶部内容,但不删除它。
nos是下面的元素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字节

...直截了当,没有花招:

档案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

1
!*叹息* ...写dc的代码肯定比解释更容易...

1
是的,我们确实需要具有某种疯狂的多堆栈可视化小工具的IDE,这真是太好了。

1
我有几个想法要添加为新命令,但是影响最大的想法似乎是:添加“更改默认堆栈”命令。;-)

2
...或用命名寄存器交换默认堆栈。这会在用户的

1
是的,那绝对方便!我还想清除一个项目,旋转不在堆栈顶部的n项目,也许一次将顶部项目转移到另一个堆栈。不过,到目前为止,我仍然不知道如何dc从源代码进行编译。:/

2

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

迭代Fib算法


鉴于此操作比我预期的要好得多,所以我想找到在5秒内返回的最大N,我得出1540,它给出的数字为247441位数字。
JustinM-恢复莫妮卡

令人印象深刻。出于好奇,1541需要花费多长时间?
熊猫编码器

@Pandacoder因此,随着最近对算法的更改,它的速度已大大提高。1541在755毫秒内,所以我现在要查找新的sub 5 max。
JustinM-恢复莫妮卡

@Pandacoder,因此运行时间大约
相差

这个号码要多久?
Pandacoder '16

2

Brain-Flak,54个字节

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

在线尝试!

对于大量输入,Brain-Flak中的乘法需要很长时间。只要乘以˚F 100被F 99与通用乘算法将需要数十亿年。

幸运的是,有一种更快的方法。以开头的广义Fibonacci序列(k, 0)将生成与通常序列相同的项,并乘以k。使用此观察,Brain-Flak可以乘以斐波纳契数,就像生成斐波那契数一样容易。

如果堆栈由-n后跟两个数字组成,{({}()<([({})]({}{}))>)}{}{}将计算n广义斐波纳契数列的迭代,并在最后一个数之前全部舍弃。程序的其余部分只是设置开头的1,并循环遍历范围内的所有数字n...1

这是该解释器提供的其他语言中的相同算法:

Brain-Flak Classic,52个字节

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

在线尝试!

脑筋,58字节

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

在线尝试!

Mini-Flak,62个字节

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

在线尝试!


1

Mathematica- 32 26字节

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

@MartinEnder切碎了6个字节!



1

Ruby,85字节

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

原来很好,但是可能有一个更短的解决方案。

快速斐波纳契计算,取自此处:链接

在这里测试


1

朱莉娅,36个字节

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

1

脑高射炮110个 104 100字节

在线尝试!

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

说明

首先,我们运行由Green Eggs和Iron Man博士提供的Fibonacci序列生成器的改进版本

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

然后,当堆栈上有多个项目时

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

将前两个项目相乘

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

然后弹出多余的零

{}

1
不幸的是,我认为这是无效的,因为输入25会花费10秒钟以上的时间。该算法效率很低(就像语言一样),因此计算100可能要花费几个小时。
DJMcMayhem

1

Clojure,70个字节

Clojure并不是编码高尔夫的好语言。那好吧。

http://tryclj.com上尝试一下。

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



1

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)

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.