Question

我想知道怎样才能找到第n个斐波那契序列的n个非常大的n值1000000。使用等级 - 学校递推方程fib(n)=fib(n-1)+fib(n-2)，需要2-3分钟才能找到第50届！

在谷歌搜索之后，我开始了解Binet的公式，但它不适用于n> 79的值，因为它是here

是否有算法可以像查找素数一样进行？

Answer 1

您可以使用矩阵求幂方法（线性递归方法）。您可以在this博客中找到详细的说明和程序。运行时间为 O （log n ）。

我认为没有更好的方法可以做到这一点。

Answer 2

您可以使用memoization节省大量时间。例如，比较以下两个版本（在JavaScript中）：

版本1 ：正常递归

var fib = function(n) {
  return n < 2 ? n : fib(n - 1) + fib(n - 2);
};

版本2 ：memoization

一个。使用underscore库

var fib2 = _.memoize(function(n) {
  return n < 2 ? n : fib2(n - 1) + fib2(n - 2);
});

B中。自由库

var fib3 = (function(){
    var memo = {};
    return function(n) {
        if (memo[n]) {return memo[n];}
        return memo[n] = (n <= 2) ? 1 : fib3(n-2) + fib3(n-1);
    };
})();

对于n = 50（在Chrome上），第一个版本需要3分钟，而第二个版本只需要不到5毫秒！您可以在jsFiddle。

中查看此内容

如果我们知道版本1的时间复杂度是指数级的（ O （2 ^{N / 2}）），那就不足为奇了，而版本2的版本是是线性的（ O （ N ））。

版本3 ：矩阵乘法

此外，我们甚至可以通过计算 N 矩阵的乘法来减少 O （log（ N ））的时间复杂度。

$matrix$

其中 F _n表示Fibonacci序列的 n 项。

Answer 3

使用重复身份http://en.wikipedia.org/wiki/Fibonacci_number#Other_identities查找n - log(n)步骤中的数字。你必须使用任意精度整数。或者你可以通过在每一步使用模运算来计算精确答案 modulo 某些因素。

recurrence formula 1

recurrence formula 2

recurrence formula 3

注意到3n+3 == 3(n+1)，我们可以设计一个单递归函数，该函数在每一步分割时计算两个顺序Fibonacci数n乘以3，并根据余数值选择合适的公式。如果它在一个步骤中从一对@(3n+r,3n+r+1), r=0,1,2计算一对@(n,n+1)，那么就没有双递归，也不需要记忆。

Haskell代码是here。

update:

F(2n-1) =   F(n-1)^2    + F(n)^2   ===   a' = a^2 + b^2 
F(2n)   = 2 F(n-1) F(n) + F(n)^2   ===   b' = 2ab + b^2

似乎可以带来更快的代码。使用"Lucas sequence identities"可能是最快的（this is due到用户：primo，引用this implementation）。

Answer 4

大多数人已经给你链接解释了Nth Fibonacci数字的发现，顺便说一句，Power算法的工作方式与微小变化相同。

无论如何，这是我的O（log N）解决方案。

package algFibonacci;

import java.math.BigInteger;

public class algFibonacci {
    // author Orel Eraki
    // Fibonacci algorithm
    // O(log2 n)
    public static BigInteger Fibonacci(int n) {

        int num = Math.abs(n);
        if (num == 0) {
            return BigInteger.ZERO;
        }
        else if (num <= 2) {
            return BigInteger.ONE;
        }

        BigInteger[][] number = { { BigInteger.ONE, BigInteger.ONE }, { BigInteger.ONE, BigInteger.ZERO } };
        BigInteger[][] result = { { BigInteger.ONE, BigInteger.ONE }, { BigInteger.ONE, BigInteger.ZERO } };

        while (num > 0) {
            if (num%2 == 1) result = MultiplyMatrix(result, number);
            number = MultiplyMatrix(number, number);
            num/= 2;
        }

        return result[1][1].multiply(BigInteger.valueOf(((n < 0) ? -1:1)));
    }

    public static BigInteger[][] MultiplyMatrix(BigInteger[][] mat1, BigInteger[][] mat2) {
        return new BigInteger[][] {
            {
                mat1[0][0].multiply(mat2[0][0]).add(mat1[0][1].multiply(mat2[1][0])), 
                mat1[0][0].multiply(mat2[0][1]).add(mat1[0][1].multiply(mat2[1][1]))
            },
            {
                mat1[1][0].multiply(mat2[0][0]).add(mat1[1][1].multiply(mat2[1][0])), 
                mat1[1][0].multiply(mat2[0][1]).add(mat1[1][1].multiply(mat2[1][1]))
            }
        };
    }

    public static void main(String[] args) {
        System.out.println(Fibonacci(8181));
    }
}

Answer 5

为了计算Fibonacci数，递归算法是最糟糕的方法之一。通过简单地在for循环中添加前两个数字（称为迭代方法）将不需要2-3分钟来计算第50个元素。

Answer 6

这是一个用于计算O（log（n））中第n个Fibonacci数的python版本

def fib(n):
    if n == 0: 
        return 0

    if n == 1: 
        return 1

    def matmul(M1, M2):
        a11 = M1[0][0]*M2[0][0] + M1[0][1]*M2[1][0]
        a12 = M1[0][0]*M2[0][1] + M1[0][1]*M2[1][1]
        a21 = M1[1][0]*M2[0][0] + M1[1][1]*M2[1][0]
        a22 = M1[1][0]*M2[0][1] + M1[1][1]*M2[1][1]
        return [[a11, a12], [a21, a22]]

    def matPower(mat, p):
        if p == 1: 
            return mat

        m2 = matPower(mat, p//2)
        if p % 2 == 0:
            return matmul(m2, m2)
        else: 
            return matmul(matmul(m2, m2),mat)

    Q = [[1,1],[1,0]]

    q_final = matPower(Q, n-1)
    return q_final[0][0]

Answer 7

首先，您可以从largest known Fibonacci term形成一个最高词的概念。另见stepping through recursive Fibonacci function presentation。有关此主题的感兴趣的方法是this article。另外，请尝试在the worst algorithm in the world?中阅读相关内容。

Answer 8

为了计算Fibonacci序列的任意大的元素，你将不得不使用闭合形式的解决方案--Binet的公式，并使用任意精度数学来提供足够的精度来计算答案。

但是，仅使用递归关系，不需要2-3分钟来计算第50个术语 - 你应该能够在任何现代的几秒钟内计算数十亿的术语机。听起来你正在使用完全递归的公式，这会导致递归计算的组合爆炸。简单的迭代公式远更快。

即：递归解决方案是：

int fib(int n) {
  if (n < 2)
    return 1;
  return fib(n-1) + fib(n-2)
}

......然后坐下来观看堆栈溢出。

迭代解决方案是：

int fib(int n) {
  if (n < 2)
    return 1;
  int n_1 = 1, n_2 = 1;
  for (int i = 2; i <= n; i += 1) {
    int n_new = n_1 + n_2;
    n_1 = n_2;
    n_2 = n_new;
  }
  return n_2;
}

请注意我们实际上是如何从之前的术语n_new和n_1计算下一个术语n_2，然后将所有术语“混乱”下一次迭代。运行时间与n的值成线性关系，对于现代千兆赫兹机器上的数十亿（在中间变量的整数溢出之后），n只需几秒钟。

Answer 9

我编写了一个C实现，支持使用GNU gmp 任意比例的输入数字。

为单个数字计算fib的时间为O(n)，缓存的空间为O(1)，（它实际上计算为0~n的所有fib）。 / p>

代码

<强> fib_cached_gmp.c：

// fibonacci - cached algorithm - any scale of input with GMP,
#include <gmp.h>
#include <stdio.h>
#include <stdlib.h>

// a single step,
void fib_gmp_next(mpz_t *cache) {
    mpz_add(cache[2], cache[0], cache[1]);
    mpz_set(cache[0], cache[1]);
    mpz_set(cache[1], cache[2]);
}

// figure fib for a single number, in O(n),
mpz_t *fib_gmp(int n, mpz_t *result) {
    // init cache,
    mpz_t cache[3]; // number: [fib(n-2), fib(n-1), fib(n)],

    mpz_init(cache[0]);
    mpz_init(cache[1]);
    mpz_init(cache[2]);

    mpz_set_si(cache[0], 0);
    mpz_set_si(cache[1], 1);

    while (n >= 2) {
        fib_gmp_next(cache);
        n--;
    }

    mpz_set(*result, cache[n]);

    return result;
}

// test - print fib from 0 to n, tip: cache won't be reused between any 2 input numbers,
void test_seq(int n) {
    mpz_t result;
    mpz_init(result);

    for (int i = 0; i <= n; i++) {
        gmp_printf("fib(%2d): %Zd\n", i, fib_gmp(i, &result));
    }
}

// test - print fib for a single num,
void test_single(int x) {
    mpz_t result;
    mpz_init(result);

    gmp_printf("fib(%d): %Zd\n", x, fib_gmp(x, &result));
}

int main() {
    // test sequence,
    test_seq(100);

    // test single,
    test_single(12345);

    return 0;
}

首先安装gmp：

// for Ubuntu,
sudo apt-get install libgmp3-dev

<强>编译：

gcc fib_cached_gmp.c -lgmp

<强>执行：

./a.out

示例输出：

fib( 0): 0
fib( 1): 1
fib( 2): 1
fib( 3): 2
fib( 4): 3
fib( 5): 5
fib( 6): 8
fib( 7): 13
fib( 8): 21
fib( 9): 34
fib(10): 55
fib(11): 89
fib(12): 144
fib(13): 233
fib(14): 377
fib(15): 610
fib(16): 987
fib(17): 1597
fib(18): 2584
fib(19): 4181
fib(20): 6765
fib(21): 10946
fib(22): 17711
fib(23): 28657
fib(24): 46368
fib(25): 75025
fib(26): 121393
fib(27): 196418
fib(28): 317811
fib(29): 514229
fib(30): 832040
fib(31): 1346269
fib(32): 2178309
fib(33): 3524578
fib(34): 5702887
fib(35): 9227465
fib(36): 14930352
fib(37): 24157817
fib(38): 39088169
fib(39): 63245986
fib(40): 102334155
fib(41): 165580141
fib(42): 267914296
fib(43): 433494437
fib(44): 701408733
fib(45): 1134903170
fib(46): 1836311903
fib(47): 2971215073
fib(48): 4807526976
fib(49): 7778742049
fib(50): 12586269025
fib(51): 20365011074
fib(52): 32951280099
fib(53): 53316291173
fib(54): 86267571272
fib(55): 139583862445
fib(56): 225851433717
fib(57): 365435296162
fib(58): 591286729879
fib(59): 956722026041
fib(60): 1548008755920
fib(61): 2504730781961
fib(62): 4052739537881
fib(63): 6557470319842
fib(64): 10610209857723
fib(65): 17167680177565
fib(66): 27777890035288
fib(67): 44945570212853
fib(68): 72723460248141
fib(69): 117669030460994
fib(70): 190392490709135
fib(71): 308061521170129
fib(72): 498454011879264
fib(73): 806515533049393
fib(74): 1304969544928657
fib(75): 2111485077978050
fib(76): 3416454622906707
fib(77): 5527939700884757
fib(78): 8944394323791464
fib(79): 14472334024676221
fib(80): 23416728348467685
fib(81): 37889062373143906
fib(82): 61305790721611591
fib(83): 99194853094755497
fib(84): 160500643816367088
fib(85): 259695496911122585
fib(86): 420196140727489673
fib(87): 679891637638612258
fib(88): 1100087778366101931
fib(89): 1779979416004714189
fib(90): 2880067194370816120
fib(91): 4660046610375530309
fib(92): 7540113804746346429
fib(93): 12200160415121876738
fib(94): 19740274219868223167
fib(95): 31940434634990099905
fib(96): 51680708854858323072
fib(97): 83621143489848422977
fib(98): 135301852344706746049
fib(99): 218922995834555169026
fib(100): 354224848179261915075
fib(12345): 400805695072240470970514993214065752192289440772063392234116121035966330621821050108284603033716632771086638046166577665205834362327397885009536790892524821512145173749742393351263429067658996935575930135482780507243981402150702461932551227590433713277255705297537428017957026536279252053237729028633507123483103210846617774763936154673522664591736081039709294423865668046925492747583953758325850613548914282578320544573036249175099094644435323970587790740267131607004023987409385716162460955707793257532112771932704816713519196128834470721836094265012918046427449156654067195071358955104097973710150920536847877434256779886729555691213282504703193401739340461924048504866698176130757935914248753973087073009601101912877383634628929467608983980664185363370286731771712542583041365328648124549323878806758395652340861186334027392307091079257180835672989798524084534677252369585918458720952520972332496025465803523315515681084895362126005441170936820059518262349022456888758938672920855739736423917065122816343192172271301981007636070751378441363091187289522144227851382197807194256392294919912037019476582418451273767976783751999133072126657949249799858935787018952232743400610036315564885371356712960608966755186612620425868892621106627825137425386831657368826398245606147944273998498356443362170133234924531673939303668042878258282104212769625245680321344034442698232414181912301904509531018692483863038992377680591406376081935756597411807864832452421993121459549055042253305545594009110753730302061881025182053074077930494574304284381890534053065639084253641881363463311184024281835265103884539012874542416238100890688593076189105555658375552988619203325356676814545718066196038345684671830102920209857682912971565838896011294918349088792184108318689299230788355618638040186790724351073650210514429114905535411044888774713860041341593318365792673354888566799196442017231870631867558530906286613228902689695061557951752309687806567573290910909535395758148994377158637050112347651517847188123790794231572729345617619677555583207012253101701328971768827861922408064379891201972881554890367344239218306050355964382953279316318309272212482218232309006973312977359562553184608144571713073802285675503209229581312057259729362382786183100343961484090866057560474044189870633912200595478051573769889968342203512550302655117491740823696686983281784153050366346823513213598551985596176977626982962058849363351794302206703907577970065793839511591930741441079234179943480206539767561244271325923343752071038968002157889912694947204003637791271084190929058369801531787887444598295425899927970

<强>提示：

test_seq()不是很聪明，它没有在2个输入数字之间重复使用缓存。
实际上只需拨打一次fib_gmp()即可，只需向gmp_printf()添加fib_gmp_next()，并在每一步中将{i}提供给fib_gmp_next()。无论如何，它只是为了演示。

Answer 10

我解决了UVA问题：495 - Fibonacci Freeze

它生成所有斐波那契数字，最高可达5000，并打印给定输入的输出（范围为1 - 5000）。

运行时00.00秒接受

5000的斐波纳契数是：

3878968454388325633701916308325905312082127714646245106160597214895550139044037097010822916462210669479293452858882973813483102008954982940361430156911478938364216563944106910214505634133706558656238254656700712525929903854933813928836378347518908762970712033337052923107693008518093849801803847813996748881765554653788291644268912980384613778969021502293082475666346224923071883324803280375039130352903304505842701147635242270210934637699104006714174883298422891491273104054328753298044273676822977244987749874555691907703880637046832794811358973739993110106219308149018570815397854379195305617510761053075688783766033667355445258844886241619210553457493675897849027988234351023599844663934853256411952221859563060475364645470760330902420806382584929156452876291575759142343809142302917491088984155209854432486594079793571316841692868039545309545388698114665082066862897420639323438488465240988742395873801976993820317174208932265468879364002630797780058759129671389634214252579116872755600360311370547754724604639987588046985178408674382863125

#include<stdio.h>
#include<string.h>

#define LIMIT 5001
#define MAX 1050
char num[LIMIT][MAX];
char result[MAX];
char temp[MAX];

char* sum(char str1[], char str2[])
{
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    int minLen, maxLen;
    int i, j, k;

    if (len1 > len2)
        minLen = len2, maxLen = len1;
    else
        minLen = len1, maxLen = len2;
    int carry = 0;
    for (k = 0, i = len1 - 1, j = len2 - 1; k<minLen; k++, i--, j--)
    {
        int val = (str1[i] - '0') + (str2[j] - '0') + carry;
        result[k] = (val % 10) + '0';
        carry = val / 10;
    }
    while (k < len1)
    {
        int val = str1[i] - '0' + carry;
        result[k] = (val % 10) + '0';
        carry = val / 10;

        k++; i--;
    }
    while (k < len2)
    {
        int val = str2[j] - '0' + carry;
        result[k] = (val % 10) + '0';
        carry = val / 10;

        k++; j--;
    }
    if (carry > 0)
    {
        result[maxLen] = carry + '0';
        maxLen++;
        result[maxLen] = '\0';
    }
    else
    {
        result[maxLen] = '\0';
    }
    i = 0;
    while (result[--maxLen])
    {
        temp[i++] = result[maxLen];
    }
    temp[i] = '\0';
    return temp;
}

void generateFibonacci()
{
    int i;
    num[0][0] = '0'; num[0][1] = '\0';
    num[1][0] = '1'; num[1][1] = '\0';
    for (i = 2; i <= LIMIT; i++)
    {
        strcpy(num[i], sum(num[i - 1], num[i - 2]));
    }
}

int main()
{
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    int N;
    generateFibonacci();
    while (scanf("%d", &N) == 1)
    {
        printf("The Fibonacci number for %d is %s\n", N, num[N]);
    }
    return 0;
}

Answer 11

最简单的Pythonic实现可以如下给出

def Fib(n):
    if (n < 0) : 
        return -1
    elif (n == 0 ): 
        return 0
    else:
        a = 1
        b = 1
        for i in range(2,n+1):
            a,b = b, a+b
        return a

Answer 12

我在c中有一个源代码来计算甚至3500th的斐波纳契数： - 有关详细信息，请访问

http://codingloverlavi.blogspot.in/2013/04/fibonacci-series.html

C中的源代码： -

#include<stdio.h>
#include<conio.h>
#define max 2000

int arr1[max],arr2[max],arr3[max];

void fun(void);

int main()
{
    int num,i,j,tag=0;
    clrscr();
    for(i=0;i<max;i++)
        arr1[i]=arr2[i]=arr3[i]=0;

    arr2[max-1]=1;

    printf("ENTER THE TERM : ");
    scanf("%d",&num);

    for(i=0;i<num;i++)
    {
        fun();

        if(i==num-3)
            break;

        for(j=0;j<max;j++)
            arr1[j]=arr2[j];

        for(j=0;j<max;j++)
            arr2[j]=arr3[j];

    }

    for(i=0;i<max;i++)
    {
        if(tag||arr3[i])
        {
            tag=1;
            printf("%d",arr3[i]);
        }
    }


    getch();
    return 1;
}

void fun(void)
{
    int i,temp;
    for(i=0;i<max;i++)
        arr3[i]=arr1[i]+arr2[i];

    for(i=max-1;i>0;i--)
    {
        if(arr3[i]>9)
        {
            temp=arr3[i];
            arr3[i]%=10;
            arr3[i-1]+=(temp/10);
        }
    }
}

Answer 13

这是一个简短的python代码，最多可以运行7位数。只需要一个3元素数组

def fibo(n):
    i=3
    l=[0,1,1]
    if n>2:
        while i<=n:
            l[i%3]= l[(i-1) % 3] + l[(i-2) % 3]
            i+=1
    return l[n%3]

Answer 14

python中更优雅的解决方案

def fib(n):
  if n == 0: 
    return 0
  a, b = 0, 1
  for i in range(2, n+1):
    a, b = b, a+b
  return b

Answer 15

通过对离散数学的一些了解，您可以在恒定时间O（1）中找到任何斐波纳契数。有一种叫做线性齐次递归关系的东西。

Fibonacci序列是一个着名的例子。

要找到第n个Fibonacci数，我们需要找到

$f_{n}=r^{n}$

我们知道

$f_{n}= f_{n-1}+f_{n-2}$

其中

$f_{0}= 0, f_{1}= 1$

然后，特征方程是

$r^{2}-r-1=0$

找到特征方程的根并代入第一个方程

$f_{n}= \alpha _{1}\left [ {\frac{1+\sqrt{5}}{2}} \right ]^{n}+\alpha _{2}\left [ \frac{1-\sqrt{5}}{2} \right ]^{n}$

最后，我们需要找到alpha 1和amp;的值。 alpha 2

$f_{n}= \frac{1}{\sqrt{5}}\left [ {\frac{1+\sqrt{5}}{2}} \right ]^{n}+\frac{1}{\sqrt{5}}\left [ \frac{1-\sqrt{5}}{2} \right ]^{n}$

现在，您可以使用此公式在O（1）中找到任何斐波纳契数。

Answer 16

#include <bits/stdc++.h>
#define MOD 1000000007
using namespace std;

const long long int MAX = 10000000;

// Create an array for memoization
long long int f[MAX] = {0};

// Returns n'th fuibonacci number using table f[]
long long int fib(int n)
{
    // Base cases
    if (n == 0)
        return 0;
    if (n == 1 || n == 2)
        return (f[n] = 1);

    if (f[n])
        return f[n];

    long long int k = (n & 1)? (n+1)/2 : n/2;

    f[n] = (n & 1)? (fib(k)*fib(k) + fib(k-1)*fib(k-1)) %MOD
        : ((2*fib(k-1) + fib(k))*fib(k))%MOD;

    return f[n];
}

int main()
{
    long long int n = 1000000;
    printf("%lld ", fib(n));
    return 0;
}

时间复杂度：O（Log n），因为我们在每次递归调用中将问题分成一半。

Answer 17

计算斐波纳契数（使用Haskell）：

版本1 ：将定义直接转换为代码（非常慢版本）：

fib :: Integer -> Integer
fib 0 = 1
fib 1 = 1
fib n =
  fib (n - 1) + fib (n - 2)

版本2 ：使用我们完成的工作来计算 F_ {n - 1} 和 F_ {n - 2} （快版）：

fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

你可以通过fibs !! n来获得第n个斐波纳契，其中n是索引。

版本3 ：使用矩阵乘法技术。（更快的版本）：

-- declaring a matrix
data Matrix = Matrix
  ( (Integer, Integer)
  , (Integer, Integer)
  )
  deriving (Show, Eq)

-- creating it an instance of Num
-- so that if we implement (*) we get (^) for free
instance Num Matrix where
  (*) = mMult

  -- don't need these
  (+) = undefined
  negate = undefined
  fromInteger = undefined
  abs = undefined
  signum = undefined


-- 2-d matrix multiplication
mMult :: Matrix -> Matrix -> Matrix
mMult (Matrix ((a11, a12), (a21, a22))) (Matrix ((b11, b12), (b21, b22))) =
  Matrix
    ( (a11 * b11 + a12 * b21, a11 * b12 + a12 * b22)
    , (a21 * b11 + a22 * b21, a21 * b12 + a22 * b22)
    )

-- base matrix for generating fibonacci
fibBase :: Matrix
fibBase =
  Matrix ((1,1), (1,0))

-- get the large fibonacci numbers
fastFib :: Int -> Integer
fastFib n =
  let
    getNth (Matrix ((_, a12), _)) = a12
  in
    getNth (fibBase ^ n)

Answer 18

仅供参考：

以下公式似乎可以正常工作，但取决于所用数字的准确性-

[（（（1 +√5）/ 2）ⁿ-（（1-√5）/ 2）ⁿ] /√5

注意：请勿将数字四舍五入以提高准确性。

JS示例代码：

let n = 74,
const sqrt5 = Math.sqrt(5);
fibNum = Math.round((Math.pow(((1+sqrt5)/2),n)- Math.pow(((1-sqrt5)/2),n))/sqrt5) ;

根据数字精度，它可以在chrome控制台上正常运行，直到 n = 74

欢迎提出任何建议！

另一种解决方案

遵循步骤-

以一定的时间间隔设置斐波那契数列的索引和值以及上一个值。例如每50个或每100个。
从 step-1 的集合中找到所需数字n的最近的下标。
以传统方式在每个后续值中添加前一个值进行操作。

注意：似乎不太好，但是如果您真的很担心时间复杂性，那么此解决方案很受欢迎。最大迭代次数等于 step-1 中的间隔。

结论：

斐波那契数与golden ratio有密切关系：Binet's formula用n和黄金比率表示第n个Fibonacci number，并暗示两个连续斐波那契数的比率倾向于随着n的增加，黄金分割率。
在纯数学中，Binet的公式每次都会为您提供准确的结果。在现实世界中，由于所需的精度超过了使用的精度，因此会出现错误。每个真实的解决方案都存在相同的问题，有时甚至超出了精度。

Answer 19

我做了一个程序。计算值并不需要很长时间，但可以显示的最大项是1477（因为双倍的最大范围）。结果几乎立即出现。该系列从0开始。如果需要进行任何改进，请随时编辑。

#include<iostream>
using namespace std;
void fibseries(long int n)
{
    long double x=0;
    double y=1;
    for (long int i=1;i<=n;i++)
     {
        if(i%2==1)
         {
            if(i==n)
             {
              cout<<x<<" ";
             }
            x=x+y;
         } 
        else 
         {
            if(i==n)
             {
              cout<<x<<" ";
             }
            y=x+y;
         }
     }
}
main()
{
    long int n=0;
    cout<<"The number of terms ";
    cin>>n;
    fibseries(n);
    return 0;
}

Answer 20

这个JavaScript实现处理nthFibonacci（1200）没有问题：

var nthFibonacci = function(n) {
    var arr = [0, 1];
    for (; n > 1; n--) {
        arr.push(arr.shift() + arr[0])
    }
    return arr.pop();
};

console.log(nthFibonacci(1200)); // 2.7269884455406272e+250

Answer 21

如果您正在使用C＃，请查看Lync和BigInteger。我尝试了1000000（实际上是1000001，因为我跳过前1000000）并且低于2分钟（00：01：19.5765）。

public static IEnumerable<BigInteger> Fibonacci()
{
    BigInteger i = 0;
    BigInteger j = 1;
    while (true)
    {
        BigInteger fib = i + j;
        i = j;
        j = fib;
        yield return fib;
    }
}

public static string BiggerFib()
{
    BigInteger fib = Fibonacci().Skip(1000000).First();
    return fib.ToString();    
}

Answer 22

我编写了一个小代码来计算大数字的Fibonacci，这比会话递归方式更快。</ p>

我正在使用记忆技术来获取最后一个Fibonacci数而不是重新计算它。

public class FabSeries {
    private static Map<BigInteger, BigInteger> memo = new TreeMap<>();

    public static BigInteger fabMemorizingTech(BigInteger n) {
        BigInteger ret;
        if (memo.containsKey(n))
            return memo.get(n);
        else {
            if (n.compareTo(BigInteger.valueOf(2)) <= 0)
                ret = BigInteger.valueOf(1);
            else
                ret = fabMemorizingTech(n.subtract(BigInteger.valueOf(1))).add(
                        fabMemorizingTech(n.subtract(BigInteger.valueOf(2))));
            memo.put(n, ret);
            return ret;
        }

    }

    public static BigInteger fabWithoutMemorizingTech(BigInteger n) {
        BigInteger ret;
        if (n.compareTo(BigInteger.valueOf(2)) <= 0)
            ret = BigInteger.valueOf(1);
        else

            ret = fabWithoutMemorizingTech(n.subtract(BigInteger.valueOf(1))).add(
                    fabWithoutMemorizingTech(n.subtract(BigInteger.valueOf(2))));
        return ret;
    }

       public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter Number");

        BigInteger num = scanner.nextBigInteger();

        // Try with memorizing technique
        Long preTime = new Date().getTime();
        System.out.println("Stats with memorizing technique ");
        System.out.println("Fibonacci Value : " + fabMemorizingTech(num) + "  ");
        System.out.println("Time Taken : " + (new Date().getTime() - preTime));
        System.out.println("Memory Map: " + memo);

        // Try without memorizing technique.. This is not responsive for large
        // value .. can 50 or so..
        preTime = new Date().getTime();
        System.out.println("Stats with memorizing technique ");
        System.out.println("Fibonacci Value : " + fabWithoutMemorizingTech(num) + " ");
        System.out.println("Time Taken : " + (new Date().getTime() - preTime));

    }
}

输入数字

40

记忆技术的统计

Fibonacci价值：102334155

拍摄时间：5

记忆图：{1 = 1,2 = 1,3 = 2,4 = 3,5 = 5,6 = 8,7 = 13,8 = 21,9 = 34,10 = 55,11 = 89 ，12 = 144,13 = 233,14 = 377,15 = 610,16 = 987,17 = 1597,18 = 2584,19 = 4181,20 = 6765,21 = 10946,22 = 17711,23 = 28657,24 = 46368,25 = 75025,26 = 121393,27 = 196418,28 = 317811,29 = 514229,30 = 832040,31 = 1346269,32 = 2178309,33 = 3524578,34 = 5702887,35 = 9227465,36 = 14930352 ，37 = 24157817,38 = 39088169,39 = 63245986,40 = 102334155}

没有记忆技术的统计数据

Fibonacci价值：102334155

拍摄时间：11558

为非常大的'n'找出第n个斐波纳契数

22 个答案:

代码