Question

我试图在不使用BigInteger类导入的情况下实现Fibonacci序列，因此我重写了我自己的add方法，我花了两天时间，但我不知道为什么前6个数字的答案是正确的其余的答案与正确的答案相反（例如，n = 7，我的答案：31正确的答案：13; n = 15，我的答案= 016，正确答案= 610），当n变大时，答案是完全错误的（甚至不是正确答案的反转。这发生在n> = 25时）。任何建议将不胜感激！

以下是我的输出：

  The 0th Fibonacci number is :
    0
    The 1th Fibonacci number is :
    1
    The 2th Fibonacci number is :
    1
    The 3th Fibonacci number is :
    2
    The 4th Fibonacci number is :
    3
    The 5th Fibonacci number is :
    5
    The 6th Fibonacci number is :
    8
    The 7th Fibonacci number is :
    31
    The 8th Fibonacci number is :
    12
    The 9th Fibonacci number is :
    43
    The 10th Fibonacci number is :
    55
    The 11th Fibonacci number is :
    98
    The 12th Fibonacci number is :
    441
    The 13th Fibonacci number is :
    332
    The 14th Fibonacci number is :
    773
    The 15th Fibonacci number is :
    016
    The 16th Fibonacci number is :
    789
    The 17th Fibonacci number is :
    7951
    The 18th Fibonacci number is :
    4852
    The 19th Fibonacci number is :
    1814
    The 20th Fibonacci number is :
    5676
    The 21th Fibonacci number is :
    64901
    The 22th Fibonacci number is :
    11771
    The 23th Fibonacci number is :
    75682
    The 24th Fibonacci number is :
    86364
    The 25th Fibonacci number is :
    52047
    The 26th Fibonacci number is :
    393021
    The 27th Fibonacci number is :
    814491
    The 28th Fibonacci number is :
    118413
    The 29th Fibonacci number is :
    922905
    The 30th Fibonacci number is :
    040428

以下是我的代码：

package com.example.helloworld;


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Fibonacci_Recursive{
    public static void main(String[] args) {
        long start = System.nanoTime();
        long time = 0L;
        for(int i = 0; time <= 60L; i++)
        {
            Fibonacci_Recursive fr = new Fibonacci_Recursive(i);
            time = ((System.nanoTime() - start) / 1000_000_000);
        }
    }

    private Fibonacci_Recursive(int n){
        System.out.println("The " + n + "th Fibonacci number is :");
        if (n <= 1){
            System.out.println(n);
        }
        else {
            int[] finalResult = getF(n);
            String st = "";
            for (int i = 0; i < finalResult.length; i++){
                st = finalResult[i] + st;
            }
            System.out.println(st);
        }
    }

    private int[] getF(int n){
        int[] head = new int[1];
        if (n <= 1) {
            head[0] = n;
            return head;
        }
        return add(getF(n - 1), getF(n - 2));
    }

    private int[] add(int[] s1, int[] s2){
        int carrier = 0;
        ArrayList<Integer> result = new ArrayList<>();
        int[] array1 = s1;
        int[] array2 = s2;
        array1 = reverseGeneralArray(array1);
        array2 = reverseGeneralArray(array2);
        int min = array2.length;
        int min2 = array1.length;

        if(min2 > min) {
            for (int i = 0; i < min; i++) {
                int x = array1[i] + array2[i];
                result.add((x + carrier) % 10);
                carrier = x / 10;
            }
            for (int j = 0; j <= min2 - min - 1; j++) {
                int index = min;
                result.add((array1[index] + carrier) % 10);
                carrier = (array1[index] + carrier) / 10;
                index++;
            }
            if (carrier > 0) {
                result.add(carrier);
            }
            Collections.reverse(result);
            return convertIntegers(result);
        }
        else if(min2 < min)
            {
                for(int i = 0; i < min2; i ++){
                    int x = array1[i] + array2[i];
                    result.add((x + carrier) % 10);
                    carrier = x / 10;
                }
                for(int j = 0; j <= min - min2 - 1; j++){
                    int index = min2;
                    result.add((array2[index] + carrier) % 10);
                    carrier = (array2[index] + carrier) / 10;
                    index++;
                }
                if (carrier > 0) {
                    result.add(carrier);
                }
                Collections.reverse(result);
                return convertIntegers(result);
            }else {
                for (int i = 0; i < min; i++) {
                    int x = array1[i] + array2[i];
                    result.add((x + carrier) % 10);
                    carrier = x / 10;
                }
                if (carrier > 0) {
                    result.add(carrier);
                }
            Collections.reverse(result);
            return convertIntegers(result);
            }

    }

    private static int[] convertIntegers(ArrayList<Integer> integers)
    {
        int[] ret = new int[integers.size()];
        for (int i=0; i < integers.size(); i++)
        {
            ret[i] = integers.get(i);
        }
        return ret;
    }

    private int[] reverseGeneralArray(int[] x){
        int[] newX = new int[x.length];
        for(int i = 0; i < x.length; i++){
            newX[i] = x[x.length - i -1];
        }
        return newX;
    }

}

Answer 1

你错过了构建结果，你从String st连接错误（反向）方式int[] finalResult：

private Fibonacci_Recursive(int n) {
    ...
    for (int i = 0; i < finalResult.length; i++) {
        //Replaced st = finalResult[i] + st by
        st = st + finalResult[i];
    }
    ...
}

额外：考虑在循环中连接字符串时，因为连接会复制整个字符串，所以要使用StringBuilder：

StringBuilder st = new StringBuilder();
for (int i = 0; i < finalResult.length; i++) {
    st.append(finalResult[i]);
}

更新：从25开始，错误变得明显：当两位数之和等于10（74025而不是75025）时，运营商不对。该错误采用add方法，其中载体应按以下方式计算：

carrier = (x + carrier) / 10;

即：你必须考虑以前的承运人。

使用递归实现fibonacci而不使用java.bignumber

1 个答案: