[英]An iterative algorithm for Fibonacci numbers
我对斐波那契数的迭代算法很感兴趣,所以我在 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
问题是您的return y
在您的函数循环内。 所以在第一次迭代之后,它已经停止并返回第一个值:1。除非当n
为0时,在这种情况下函数本身返回0
,而在n
为1的情况下,当for循环不会迭代时甚至一次,并且没有return
正在执行(因此None
返回值)。
要解决这个问题,只需将return y
移到循环之外。
按照 KebertX 的示例,这是我个人在 Python 中制作的解决方案。 当然,如果您要处理许多 Fibonacci 值,您甚至可能想要组合这两种解决方案并为数字创建缓存。
def f(n):
a, b = 0, 1
for i in range(0, n):
a, b = b, a + b
return a
您在循环中返回一个值,因此函数在 y 的值变得大于 1 之前退出。
如果我可以建议更短,更pythonful的东西:
def fibs(n):
fibs = [0, 1, 1]
for f in range(2, n):
fibs.append(fibs[-1] + fibs[-2])
return fibs[n]
这将与您的算法做完全相同的事情,但它不会创建三个临时变量,而是将它们添加到列表中,并按索引返回第 n 个斐波那契数。
在 fib(0) 上,您返回 0,因为:
if (n == 0) {
return 0;
}
在 fib(1) 上,您返回 1,因为:
y = 1
return y
在 fig(2) 上,您返回 1 是因为:
y = 1
return y
...等等。 只要return y
在您的循环内,该函数每次都会在您的 for 循环的第一次迭代中结束。
这是另一个用户提出的一个很好的解决方案: 如何在 Python 中编写斐波那契数列
python中的非递归斐波那契数列
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]
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
打印纤维(4)
这项工作(直觉上)
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
这个简单但最快的方法怎么样......(我刚刚发现!)
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 次加法。
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
另一种可能的方法:
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))
假设斐波那契数列的这些值:
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;
}
可能的解决方案:
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))
对于特定的程序,可以使用以下代码
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
当前值
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 个斐波那契数。 它还返回数字的长度而不是整数,这将花费很长时间。
我的另一个可以转到第二个斐波那契数,如内置时钟所示:在 10^-6 秒内。 这个可以在大约 5^-6 内完成。 我将很快获得一些更高级的算法,并以最快的速度改进它们。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.