0

我正在学习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]);  
   }
}
4

6 回答 6

1

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

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-16T00:39:42.750 回答
1

你应该寻找一个递归的答案，这个网站上有很多。例如。斐波那契数列 - 递归求和

于 2013-03-16T00:29:33.453 回答
0

如果您想将所有值存储在数组中，我会说您所做的方式是解决此问题的最优雅和最有效的方式。但是，不必存储这些值。

在美学方面，您的计数变量和数字 0 和 1 周围的圆括号不是必需的，并且使代码阅读起来非常混乱。

于 2013-03-16T00:39:59.593 回答
0

我可以制作的最优雅、结构最完善的生成斐波那契数列的程序是：

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-22T16:22:48.957 回答
0

曾经测试过这样的解决方案吗？它使用 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越高，幼稚或递归算法越慢或内存消耗越多。以下递归示例适用于我直到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-16T18:51:16.130 回答
0

这是我能做的最短的：

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-16T02:44:09.770 回答