浅谈面试中的斐波纳契数列实现与无限精度大数运算的一种思路

奉上前端面试题目一道：求斐波纳契数列的第200项。

不假思考，闭眼直接上码：

var a = 1,
    b = 1,
    c;
for (let i = 2; i < 200; i++) {
    c = a + b;
    a = b;
    b = c;
}
console.log(c);

这基本就凉了。为啥？且看输出：2.8057117299251016e+41，这是个什么鬼？

原因在于这个数太大了，已超出长整数的边界。怎么办呢？

在java中就比较容易，因为在java中提供了BigInteger类。

BigInteger a = BigInteger.valueOf(1);
BigInteger b = BigInteger.valueOf(1);
BigInteger c = null;
for (var i = 2; i < 1000; i++) {
    c = a.add(b);
    a = b;
    b = c;
}
System.out.println(c);

因为BigInteger提供无限精度运算，所以输出第1000项也没问题。

那么在js中怎么实现呢？最简单的一个办法就是将参与运算的两个操作数转换成数组，模拟按位进行加操作即可。如下：

function BigInteger(n) {
    if (Array.isArray(n)) {
        this.metaArray = n;
    } else if (typeof(n) == "number") {
        this.metaArray = toMetaArray(n + "");
    } else if (typeof(n) == "string") {
        this.metaArray = toMetaArray(n);
    }

    //实现两个BigInteger实例相加，返回值仍是BigInteger
    this.add = function(another) {
        var a = this.metaArray;
        var b = another.metaArray;
        var i = 0;
        var c = [];
        while (true) {
            var t = (a[i] ? a[i] : 0) + (b[i] ? b[i] : 0);
            if (c[i]) {
                t += c[i];
            }
            c[i] = t % 10;
            if (t / 10 >= 1) {
                c[i + 1] = parseInt(t / 10);
            }
            i++;
            if (i >= a.length && i >= b.length) {
                break;
            }
        }
        return new BigInteger(c);
    };

    //将BigIneger实例用字符串显示
    this.toString = function() {
        return this.metaArray.reverse().join("");
    };

    function toMetaArray(charsequence) {
        var array = charsequence.split("").reverse();
        for (var i = 0; i < array.length; i++) {
            array[i] = parseInt(array[i]);
        }
        return array;
    }
}

function fib(n) {
    var a = new BigInteger(1);
    var b = new BigInteger(1);
    var c;
    for (var i = 0; i < n - 2; i++) {
        c = a.add(b);
        a = b;
        b = c;
    }
    return c;
}

console.log(fib(1000).toString());

为了计算方便，在转换成数组时，数组逆向存储。

 

再举一个例子，北京大学poj第一道题目。链接地址：http://poj.org/problem?id=1001，题目如下：

Description

Problems involving the computation of exact values of very large magnitude and precision are common. For example, the computation of the national debt is a taxing experience for many computer systems.

This problem requires that you write a program to compute the exact value of Rⁿ where R is a real number ( 0.0 < R < 99.999 ) and n is an integer such that 0 < n <= 25.

Input

The input will consist of a set of pairs of values for R and n. The R value will occupy columns 1 through 6, and the n value will be in columns 8 and 9.

Output

The output will consist of one line for each line of input giving the exact value of R^n. Leading zeros should be suppressed in the output. Insignificant trailing zeros must not be printed. Don't print the decimal point if the result is an integer.

Sample Input

95.123 12
0.4321 20
5.1234 15
6.7592  9
98.999 10
1.0100 12

Sample Output

548815620517731830194541.899025343415715973535967221869852721
.00000005148554641076956121994511276767154838481760200726351203835429763013462401
43992025569.928573701266488041146654993318703707511666295476720493953024
29448126.764121021618164430206909037173276672
90429072743629540498.107596019456651774561044010001
1.126825030131969720661201

本题目同样属于无限精度的大数运算，只不过不是加法运算，而是指数运算。如第一行输入，要计算的就是95.123的12次方。

由于这是一道算法题，且有时间限制，所以以下使用C语言实现：

#define ARRAY_SIZE 200

//函数原型声明
//计算整数n的m次方，在本题目中未使用到
void resolve1(int n, int m);
//计算某数a的m次方，数字a使用数组n表示，len表示数组中有效数字的个数，数字a包括p位小数
void resolve2(int n[], int len, int p, int m);

/*
题目编号：poi-1001
测试平台：Inter(R) Core i7-6700K 4.5G 4核心8线程，内存32GB，windows 10 64位企业版。
本解法未使用任何数据结构，仅数组而已，当然需要一点想象力，本解法未进行任何优化。
本解法的缺点是调用了strlen函数及strchr函数，这两个函数对字符数组都是会遍历的。

author:snow1k
version:1.0.0

*/
int main() {
    //计算n^m，其中0.0 < n < 99.999，0 < m <= 25
    //例如：int n = 95.123,m=12;

    char s[20];//以字符串形式读入一行数据，即一个实数
    int n[20];//将对应读入的一个字符串数字转换为整数数组存储，每个数组元素存储一位数字
    int m;//指数。即读入的每行数字的第2个数字，整数

    //循环获取输入
    while(scanf("%s %d", s, &m) != EOF) {
        //若有小数点，去掉小数点的前缀0，去掉小数点的后缀0，去掉小数点，记录小数位数
        int len = strlen(s);//字符串长度，strlen是通过遍历获取长度
        //如果s为char[]类型，则要通过strchr(s,'.')-s来获取字符在字符串中的位置
        int dotIdx = strchr(s, '.') - s; //小数点位置
        int lft = 0; //左指针
        int rgt = len - 1; //右指针

        while(lft < rgt) { //去除前缀0和小数点，左指针向右前进到第一个有效数字
            if(s[lft] == '0' || s[lft] == '.') {
                lft++;
            } else {
                break;
            }
        }

        if(dotIdx >= 0) { //如果存在小数点
            while(rgt > lft) { //去除后缀0和小数点，右指针向左前进到第一个有效数字
                if(s[rgt] == '0' ) {
                    rgt--;
                } else if(s[rgt] == '.') {
                    rgt--;
                    break;
                } else {
                    break;
                }
            }
        }

        //小数位数，精度
        int precision = rgt - dotIdx;
        if(precision < 0) {
            precision = 0;
        }

        //此时，右指针指向右侧第一个有效数字，左指针指向左侧第一个有效数字
        int ct = 0;//有效数字个数
        while(rgt >= lft) {
            if(s[rgt] != '.') {
                n[ct++] = s[rgt] - 48;
            }
            rgt--;
        }
        resolve2(n, ct, precision, m);
    }
    return 0;
}


//计算n^m，即整数n的m次方
void resolve1(int n, int m) {
    //对于本题目来说，最长6位，此处定义了20位
    int arr[20];
    //乘数有效位数定位索引
    int idx = 0;

    while(n > 0) {
        arr[idx++] = n % 10;
        n /= 10;
    }

    resolve2(arr, idx, 0, m);
}


//len：数组n中有效数字个数，m:指数，p:小数精度，即小数位数
void resolve2(int n[], int len, int p, int m) {
    //////////////////
    //被乘数数组。必须是static类型的，如果不是static，则是存放在堆内存中，堆内存容量有限，容易溢出
    static int arr1[ARRAY_SIZE];
    arr1[0] = 1;
    //被乘数数组有效位数定位索引
    int arr1_idx = 0;
    int *p1 = arr1;

    //////////////////
    //结果数组
    static int arr3[ARRAY_SIZE];
    //结果数组有效位数定位索引
    int arr3_idx = -1;
    int *p3 = arr3;

    //计算n^m
    for(int i = 0; i < m; i++) {
        for(int k = 0; k < len; k++) { //乘数，最多6位
            for(int j = 0; j <= arr1_idx; j++) { //被乘数，位数不定
                if(arr3_idx < j + k) {
                    arr3_idx++;
                    *(p3 + arr3_idx) = 0;
                }

                *(p3 + j + k) += *(p1 + j) * n[k];

                if(*(p3 + j + k) >= 10) {
                    if(arr3_idx < j + k + 1) {
                        arr3_idx++;
                        *(p3 + arr3_idx) = 0;
                    }

                    *(p3 + j + k + 1) += *(p3 + j + k) / 10;
                    *(p3 + j + k) = *(p3 + j + k) % 10;
                }
            }
        }


        //将被乘数与结果交换
        int *p = p1;
        p1 = p3;
        p3 = p;

        arr1_idx = arr3_idx;
        arr3_idx = -1;

    }

    //显示最终结果
    if(arr1_idx < p * m) {//如果结果为小于0的小数，则补小数点和0
        printf(".");
        for(int i = 0; i < p * m - arr1_idx - 1; i++) {
            printf("0");
        }
    }


    for(int i = arr1_idx; i >= 0; i--) {
        if(i == p * m - 1) {
            printf(".");
        }
        printf("%d", *(p1 + i));
    }

    printf("\n");
}

若有其它建议，欢迎在下留言。

-----完------