有没有比这更好的显示斐波那契数列的方法？

我正在学习java，正在练习数组。我决定生成一个斐波那契数列作为实验，并且不禁想到可能有更简单的方法来生成这个系列（使用数组和循环）。有没有比这更好的显示斐波那契数列的方法？

有什么想法？

//Generate a Fibonacci series 
public class Array { 

    public static void main(String[] args) { 
     // An array to store the values 
     int[] intArray = new int[20]; 

     // starting values for the sequence 
     intArray[0] = 0; 
     intArray[1] = 1; 

     //display the first values 
     System.out.println("array["+(0)+"] = "+intArray[0]); 
     System.out.println("array["+(1)+"] = "+intArray[1]); 

     //generate the fibonnacci progression with a loop 
     for (int count=2;count<intArray.length;count++){ 
     intArray[count] = intArray[(count-1)]+intArray[(count-2)]; 
     System.out.println("array["+(count)+"] = "+intArray[count]); 
    } 
}

来源

2013-03-16 Axle Max

我会说你所做的是，如果你想所有的值存储在数组中解决这个问题的最优雅，最有效的方式方法。然而，存储值不是必需的。

从审美的角度来看，你的count变量和数字0和1的圆括号是没有必要的，并且使代码相当混乱。

来源

2013-03-16 00:39:59 rpamely

你应该寻找一个递归的答案，其中有很多这个网站。例如。 fibonacci series - recursive summation

来源

2013-03-16 00:29:33

我总是尽管斐波那契是，当不使用递归的解决方案很好的例子。因为最终汇总的唯一数字在递归尾部为1，因此运行时间与结果成正比。 – devconsole 2013-03-16 00:36:26

动态编程解决方案绝对没有错。 – Makoto 2013-03-16 00:38:07

简单的迭代解决方案也没有问题，但递归解决方案是优雅的，效率不高，但问题在于优雅。 – 2013-03-16 00:40:56

这是一个无数组解决方案 - 仅使用了4个int。

public class Fibonacci 
{ 
    public static void main(String[] args) 
    { 
     int first = 0; 
     int second = 1; 
     int sum; 
     for (int i = 0; i < 20; i++) 
     { 
     sum = first + second; 
     System.out.println("iteration " + i + ": " + sum); 
     first = second; 
     second = sum; 
     } 
    } 
}

输出：

iteration 0: 1 
iteration 1: 2 
iteration 2: 3 
iteration 3: 5 
iteration 4: 8 
iteration 5: 13 
iteration 6: 21 
iteration 7: 34 
iteration 8: 55 
iteration 9: 89 
iteration 10: 144 
iteration 11: 233 
iteration 12: 377 
iteration 13: 610 
iteration 14: 987 
iteration 15: 1597 
iteration 16: 2584 
iteration 17: 4181 
iteration 18: 6765 
iteration 19: 10946

来源

2013-03-16 00:39:42 rgettman

这是最短的，我可以做了：

public static void main(String[] args) { 
    int a = 0, b = 1; 
    long length = 20; 
    System.out.println(a); 
    System.out.println(b); 
    while (--length >= 0) 
     System.out.println((a = (b = a + b) - a) * 0 + b); 
}

给出：

0 1 1 2 3 5 8 13 ...

来源

2013-03-16 02:44:09

测试过像这样的一个解决方案吗？它使用Moivre-Binet公式。长型我得到精度误差对于n> 71.

public static void main(String[] args) { 
    for (int i = 0; i < 20; i++) { 
     System.out.println(getFibonacci(i)); 
    } 
} 

private static int getFibonacci(int n) { 
    return (int) ((1D/Math.sqrt(5D)) * ((Math.pow(((1D + Math.sqrt(5D))/2D), n)) - Math.pow(((1D - Math.sqrt(5D))/2D), n))); 
}

越高Ñ较慢或存储器饥饿的幼稚或递归算法。以下递归示例适用于我，最多可使用n = 14832。可能正在等待我的当前JVM设置。

static final Map<Integer,BigInteger> FIBONACCI_RESULTS = new HashMap<>(); 


private static BigInteger getFibonacciRecursive(final int n) { 
    return ((n == 1) || (n == 2)) ? BigInteger.ONE : fetchResult(n); 
} 

private static BigInteger fetchResult(final int n) { 
    BigInteger result; 
    System.out.println("n := "+n); 
    if (FIBONACCI_RESULTS.containsKey(n)) { 
     result = FIBONACCI_RESULTS.get(n); 
    } else { 
     result = getFibonacciRecursive(n - 1).add(getFibonacciRecursive(n - 2)); 
     FIBONACCI_RESULTS.put(n, result); 
    } 
    return result; 
}

来源

2013-03-16 18:51:16 vhunsicker

最优雅，结构合理的程序来生成斐波那契数列，我可以做的是：

import java.util.Scanner; 

public class fibon{ 

    public static void main(String[] args) { 
     Scanner scan = new Scanner(System.in); 
     System.out.println("How many times shall we generate the fibonacci series?"); 
     int max = scan.nextInt(); 
     scan.close(); 
     fibgen(max); 
    } 
    public static void fibgen(int max) { 
     int f = 0, s = 1; 
     for(int i = 0; i <= max; i++) { 
      f += s; 
      s = f - s; 
      System.out.println(s + " "); 
     } 

    } 
}

来源

2014-09-22 16:22:48 aetos

有没有比这更好的显示斐波那契数列的方法？

回答

相关问题