Question

我真的很厌烦数学。我的意思是，我真的很喜欢数学。我正在尝试为我将使用的算法制作一个简单的斐波那契序列类。我看过python示例，看起来像这样：

a = 0
b = 1
while b < 10:
    print b
    a, b = b, b+a

问题是我无法用任何其他语言实现这项工作。我想让它在Java中工作，因为我几乎可以将它翻译成我在那里使用的其他语言。这是一般的想法：

    public class FibonacciAlgorithm {

    private Integer a = 0;

    private Integer b = 1;

    public FibonacciAlgorithm() {

    }

    public Integer increment() {
        a = b;
        b = a + b;
        return value;
    }

    public Integer getValue() {
        return b;
    }
}

我最终得到的就是加倍，我可以用乘法来做:( 谁能帮我吗？数学让我感到高兴。

Answer 1

我这样做：

public class FibonacciAlgorithm {

    private int a = 0;

    private int b = 1;

    public FibonacciAlgorithm() {

    }

    public int increment() {
        int temp = b;
        b = a + b;
        a = temp;
        return value;
    }

    public int getValue() {
        return b;
    }
}

这使它尽可能接近原始Java代码。

[编者注：Integers已替换为ints。我没有理由使用Integers。]

Answer 2

该行

a, b = b, b+a

不容易翻译。就是这样的。你可以简化它。这是字面意义。

t1 = b
t2 = b+a
a = t1
b = t2

Answer 3

您需要先将a或b的值存储在临时变量中;

    public Integer increment() 
    {                
            int temp = a;
            a = b;
            b = temp + b;
            return value;
    }

Answer 4

Java整数只能存储前46个Fibonacci数字，使用查找表。

Answer 5

我只会翻译您之前的代码：

public void fibb(int max) {
  int a = 0;
  int b = 1;
  while (a < max) {
    System.out.println(a);
    int temp = a + b;
    a = b;
    b = temp;
  }
}

Answer 6

你不想创建一个返回第n个Fibnoacci数的函数吗？这就是我记得我小时候被教导的方式：

public int Fibb(int index) {
if (index < 2)
    return 1;
else
    return Fibb(index-1)+Fibb(index-2);
};

鉴于定义是第一对Fibbonaci数字是1，其他一切都是基于此。现在，如果你只想打印出Fibonaccis，那么循环可能会更简单，这是很多其他回复所涵盖的内容。

Answer 7

Python-to-Java转换的主要问题是Python的赋值语句一次执行，而Java则是串行执行的。 Python的陈述相当于这样说：

Make a list out of 'b' and 'a + b'
Make another list out of references to 'a' and 'b'
Assign all the elements from the second list to the first one

（它可能实际上是一个元组，我对Python不是很精通。）

因此'b'和'a + b'在分配之前解析为值。你不能在Java中进行那种多同时分配。

一般来说，Python中的语句如

var1, var2, ...varN = expression1, expression2, ...expressionN

将在Java中翻译为

temp1 = expression1;
temp2 = expression2;
...
tempN = expressionN;
var1 = temp1;
var2 = temp2;
...
varN = tempN;

这样，所有表达式都会在分配之前解析为值，并且所有赋值都不会对表达式产生副作用。

如果我真的这样做，我可能会做查找表并存储多头（因为斐波纳契数字的指数增长模糊，我想要超过46）。像你一样，迭代形式将采用O（N）来计算第N个Fibonacci值;典型的递归公式将使用与返回值一样多的函数调用。 Fibonacci实际上需要在某处缓存答案，这将使递归形式更加可行。

Answer 8

上面发布了一个递归解决方案，但这个解决方案是尾递归的，所以它线性增长。

public class Fibonacci {
    public long fibonacci(int number) {
        return fib(0,1,number);
    }

    private long fib(long result, long next, int n) {
        if (n == 0)
            return result;
        else
            return fib(next, result+next, n-1);
    }
}

Answer 9

我会这样做

fib = 100;
for(int a = 1, b = 0;a <= fib;a += b, b = (a-b)) {
    System.out.print(a + ",");
}

Answer 10

public Integer increment（）{ a = b; b = a + b; 回报值; }

肯定是错的。我认为切换前两行应该可以解决问题

如何在Java中创建Fibonacci序列

10 个答案: