Question

我对Fibonacci数的迭代算法很感兴趣，所以我在wiki上找到了公式...它看起来很直接，所以我在Python中尝试了它...它没有问题编译和公式看起来正确。 ..不确定为什么它给出了错误的输出......我没有实现它吗？

def fib (n): 
    if( n == 0):
        return 0
    else:
        x = 0
        y = 1
        for i in range(1,n):
            z = (x + y)
            x = y
            y = z
            return y

for i in range(10):
    print (fib(i))

输出

0
  无
  1
  1
  1
  1
  1
  1

Answer 1

问题是你的return y在你的函数循环中。因此，在第一次迭代之后，它将已经停止并返回第一个值：1。除非n为0，在这种情况下，函数将返回0本身，并且{{1}当for循环不会迭代一次，并且没有n正在执行时（因此return返回值），这是1。

要解决此问题，只需将None移到循环外部。

替代实施

按照KebertX的例子，这是我个人用Python制作的解决方案。当然，如果您要处理许多Fibonacci值，您甚至可能希望将这两个解决方案组合起来并为数字创建缓存。

return y

Answer 2

您在循环中返回一个值，因此该函数在y的值变为任何大于1之前退出。

如果我可以提出更短的内容，而且更加狡猾：

def fibs(n):                                                                                                 
    fibs = [0, 1, 1]                                                                                           
    for f in range(2, n):                                                                                      
        fibs.append(fibs[-1] + fibs[-2])                                                                         
    return fibs[n]

这将与您的算法完全相同，但不是创建三个临时变量，而是将它们添加到列表中，并按索引返回第n个斐波纳契数。

Answer 3

在fib（0）上，你返回0因为：

if (n == 0) {
    return 0;
}

在fib（1）上，你返回1是因为：

y = 1
return y

在图（2）中，你返回1是因为：

y = 1
return y

......等等。只要return y在循环中，函数就会在每次for循环的第一次迭代时结束。

这是另一位用户提出的一个很好的解决方案： How to write the Fibonacci Sequence in Python

Answer 4

python中的非递归Fibonacci序列

def fibs(n):
    f = []
    a = 0
    b = 1
    if n == 0 or n == 1:
        print n
    else:
        f.append(a)
        f.append(b)
        while len(f) != n:
            temp = a + b
            f.append(temp)
            a = b
            b = temp

    print f

fibs(10)

输出： [0,1,1,2,3,5,8,13,21,34]

Answer 5

假设斐波那契序列的这些值：

F（0）= 0;

F（1）= 1;

F（2）= 1;

F（3）= 2

对于N的值> 2我们将用这个公式计算斐波纳契值：

F（N）= F（N-1）+ F（N-2）

我们可以采用的一种迭代方法是计算从N = 0到N = Target_N的斐波那契，因为我们这样做，我们可以跟踪先前的斐波纳契对于N-1和N-2的结果

public int Fibonacci(int N)
{
    // If N is zero return zero
    if(N == 0)
    {
        return 0;
    }

    // If the value of N is one or two return 1
    if( N == 1 || N == 2)
    {
       return 1;
    }

    // Keep track of the fibonacci values for N-1 and N-2
    int N_1 = 1;
    int N_2 = 1;

    // From the bottom-up calculate all the fibonacci values until you 
    // reach the N-1 and N-2 values of the target Fibonacci(N)
    for(int i =3; i < N; i++)
    {
       int temp = N_2;
       N_2 = N_2 + N_1;
       N_1 = temp;
    }

    return N_1 + N_2; 
}

Answer 6

def fibiter(n):
    f1=1
    f2=1
    tmp=int()
    for i in range(1,int(n)-1):
        tmp = f1+f2
        f1=f2
        f2=tmp
    return f2

或并行分配：

def fibiter(n):
    f1=1
    f2=1
    for i in range(1,int(n)-1):
        f1,f2=f2,f1+f2
    return f2

print fibiter（4）

Answer 7

我在another thread遇到了这个问题，它比我尝试的任何其他事情都要快得多，并且不会超时。这是数学的link。

def fib(n):
    v1, v2, v3 = 1, 1, 0  
    for rec in bin(n)[3:]: 
        calc = v2*v2
        v1, v2, v3 = v1*v1+calc, (v1+v3)*v2, calc+v3*v3
        if rec=='1':    v1, v2, v3 = v1+v2, v1, v2
    return v2

Answer 8

这项工作（直观）

def fib(n):
    if n < 2:
        return n
    o,i = 0,1
    while n > 1:
        g = i
        i = o + i
        o = g
        n -= 1
    return i

Answer 9

这种简单但最快的方式怎么样......（我刚刚发现！）

def fib(n):
    x = [0,1]
    for i in range(n >> 1):
        x[0] += x[1]
        x[1] += x[0]
    return x[n % 2]

请注意！因此，这个简单的算法只使用1个赋值和1个加法，因为循环长度缩短为1/2，每个循环包括2个赋值和2个加法。

Answer 10

fcount = 0 #a count recording the number of Fibonacci numbers generated
prev = 0
current = 0
next = 1
ll = 0 #lower limit
ul = 999 #upper limit

while ul < 100000:
    print("The following Fibonacci numbers make up the chunk between %d and %d." % (ll, ul))
    while next <= ul:
        print(next)
        prev = current
        current = next
        next = prev + current
        fcount += 1 #increments count

    print("Number of Fibonacci numbers between %d and %d is %d. \n" % (ll, ul, fcount))        
    ll = ul + 1 #current upper limit, plus 1, becomes new lower limit
    ul += 1000 #add 1000 for the new upper limit
    fcount = 0 #set count to zero for a new batch of 1000 numbers

Answer 11

另一种可能的方法：

a=0
b=1
d=[a,b]
n=int(input("Enter a number"))
i=2
while i<n:
    e=d[-1]+d[-2]
    d.append(e)
    i+=1
print("Fibonacci series of {} is {}".format(n,d))

Answer 12

import time

a,b=0,1
def fibton(n):
    if n==1:
        time.clock()
        return 0,time.clock()
    elif n==2:
        time.clock()
        return 1,time.clock()
    elif n%2==0:
        read="b"
    elif n%2==1:
        read="a"
    else:
        time.clock()
        for i in range(1,int(n/2)):
            a,b=a+b,a+b
        if read=="b":
            return b,time.clock()
        elif read=="a":
            return.a,time.clock()

免责声明：我目前使用移动设备，这可能不完全正确

这种算法利用了其他一些民族的差距，现在它的速度提高了两倍。而不是仅将b设置为a，反之亦然，然后将a设置为a+b，我只需再添加2个字符即可完成两次。我还根据我的其他迭代算法的方式添加了速度测试。这应该能够在一秒内达到约200,000斐波纳契数。它还返回数字的长度而不是整数，这将需要永远。

我的另一个可以转到第二个Fibonacci数字，如内置时钟所示：10 ^ -6秒。这个可以在5 ^ -6左右做到。我将尽快获得一些更高级的算法，并以最快的速度进行优化。

Answer 13

可能的解决方案：

a=0
b=1
d=[a,b]
n=int(input("Enter a number"))
i=0
while len(d)<n:
    temp=a+b
    d.append(temp)
    a=temp
    b=d[i+1]
    i+=1
print("Fibonacci series of {} is {}".format(n,d))

Answer 14

具体来说，您可以使用以下代码

def fib (n): 
if( n == 0):
    return 0
else:
    x = 0 
    y = 1 
    for i in range(1,n):
        y =y+x
        x=y
    return y

for i in range(10):
    print (fib(i))

此处，x是旧值，y是当前值。在循环中，将y（当前值）替换为y+x（当前值+旧值），然后将当前值分配给x.Print当前值

Fibonacci数的迭代算法

14 个答案:

替代实施