如何写斐波纳契数列？
我最初错误地编写了程序。我没有在一个范围（即startNumber 1，endNumber 20应该=只有1和20之间的数字）之间返回Fibonacci数字，而是为程序编写了显示范围之间的所有Fibonacci数字（即startNumber 1，endNumber） 20显示=前20个斐波那契数字）。我以为我有一个确定的代码。我也不明白为什么会这样。
startNumber = int(raw_input("Enter the start number here "))
endNumber = int(raw_input("Enter the end number here "))
def fib(n):
if n < 2:
return n
return fib(n-2) + fib(n-1)
print map(fib, range(startNumber, endNumber))
有人在我的第二部分（由于是重复 - https://stackoverflow.com/questions/504193/how-to-write-the-fibonacci-sequence-in-python-part-ii而关闭）指出，我需要使用while循环将startNumber和endNumber传递给生成器。有人可以指点我如何做到这一点？欢迎任何帮助。
我是一名学习程序员，而且我遇到了一些混乱。我被要求编写一个程序，用于通过用户输入的起始编号和结束编号来计算和显示斐波纳契序列（即startNumber = 20 endNumber = 100，它将仅显示该范围之间的数字）。诀窍是包含它（我不知道如何在Python中使用它？ - 我假设这意味着使用包含范围？）。
到目前为止，我没有实际编码，而是：
- 将Fib序列公式写为无限
- 仅从Fib序列显示startNumber到endNumber。
我不知道从哪里开始，我正在寻求有关如何写这个的想法或见解。我也尝试过编写Fib序列论坛，但我也迷失了。
48 个答案:
答案 0 :(得分：238)
在wikipedia和wolfram上有很多关于斐波纳契数列的信息。比你可能需要的要多得多。无论如何，学习如何使用这些资源来找到（如果可能的话）你需要的东西是一件好事。
将Fib序列公式写入无限
在数学中，它是以递归形式给出的：
在编程中，无限不存在。您可以使用递归表单直接在您的语言中翻译数学表单，例如在Python中它变为：
def F(n):
if n == 0: return 0
elif n == 1: return 1
else: return F(n-1)+F(n-2)
以您喜欢的语言尝试，并且当n变大时，看到此表单需要很多时间。事实上，这是O（2 n ）及时。
继续浏览我与您关联的网站，并会看到此信息（在wolfram上）：
在Python中，这个非常容易实现并且非常非常快速地计算：
from math import sqrt
def F(n):
return ((1+sqrt(5))**n-(1-sqrt(5))**n)/(2**n*sqrt(5))
另一种方法是遵循定义（来自wikipedia）：
序列的第一个数字是0， 第二个数字是1，每个 后续数字等于总和 前两个数字的 序列本身，产生序列 0,1,1,2,3,5,8等
如果您的语言支持迭代器，您可以执行以下操作：
def F():
a,b = 0,1
while True:
yield a
a, b = b, a + b
仅从Fib序列显示startNumber到endNumber。
一旦你知道如何生成Fibonacci数字，你只需要循环数字并检查它们是否验证了给定的条件。
假设你现在写了一个f（n），它返回Fibonacci序列的第n项（就像sqrt（5）那样）
在大多数语言中，您可以执行以下操作：
def SubFib(startNumber, endNumber):
n = 0
cur = f(n)
while cur <= endNumber:
if startNumber <= cur:
print cur
n += 1
cur = f(n)
在python中我会使用迭代器表单并转到：
def SubFib(startNumber, endNumber):
for cur in F():
if cur > endNumber: return
if cur >= startNumber:
yield cur
for i in SubFib(10, 200):
print i
我的提示是学会阅读你需要的东西。项目欧拉（谷歌为它）将训练你这样做：P 祝你好运，玩得开心！
答案 1 :(得分：24)
为什么不简单地执行以下操作？
x = [1,1]
for i in range(2, 10):
x.append(x[-1] + x[-2])
print(', '.join(str(y) for y in x))
答案 2 :(得分：20)
Fibonacci序列背后的想法显示在以下Python代码中：
def fib(n):
if n == 1:
return 1
elif n == 0:
return 0
else:
return fib(n-1) + fib(n-2)
这意味着fib是一个可以做三件事之一的函数。它将fib（1）== 1，fib（0）== 0和fib（n）定义为：
fib（n-1）+ fib（n-2）
其中n是任意整数。这意味着例如fib（2）扩展为以下算法：
fib(2) = fib(1) + fib(0)
fib(1) = 1
fib(0) = 0
# Therefore by substitution:
fib(2) = 1 + 0
fib(2) = 1
我们可以用下面所示的算法以相同的方式计算fib（3）：
fib(3) = fib(2) + fib(1)
fib(2) = fib(1) + fib(0)
fib(2) = 1
fib(1) = 1
fib(0) = 0
# Therefore by substitution:
fib(3) = 1 + 1 + 0
这里要认识到的重要一点是，如果不计算fib（2）就无法计算fib（3），而fib（2）是通过知道fib（1）和fib（0）的定义来计算的。像fibonacci函数一样调用函数会被称为递归，这是编程中的一个重要主题。
这听起来像是家庭作业，所以我不打算为你做开始/结束部分。 Python虽然是一种非常富有表现力的语言，所以如果你理解数学，这应该是有意义的，并且希望教你递归。祝你好运！
编辑：对我的代码的一个潜在批评是它不使用超级方便的Python函数yield，这使得fib（n）函数缩短了很多。我的例子有点更通用，因为Python之外的很多语言实际上并没有产生。
答案 3 :(得分：12)
时间复杂度：
缓存功能通过消除Fibonacci的递归树中的重复，减少了从 O（2 ^ n）到 O（n）计算Fibonacci序列的常规方法系列：
代码：
import sys
table = [0]*1000
def FastFib(n):
if n<=1:
return n
else:
if(table[n-1]==0):
table[n-1] = FastFib(n-1)
if(table[n-2]==0):
table[n-2] = FastFib(n-2)
table[n] = table[n-1] + table[n-2]
return table[n]
def main():
print('Enter a number : ')
num = int(sys.stdin.readline())
print(FastFib(num))
if __name__=='__main__':
main()
答案 4 :(得分：8)
使用O（log n）基本算术运算非常有效。
def fib(n):
return pow(2 << n, n + 1, (4 << 2*n) - (2 << n) - 1) % (2 << n)
这个使用O（1）基本算术运算，但中间结果的大小很大，因此效率不高。
def fib(n):
return (4 << n*(3+n)) // ((4 << 2*n) - (2 << n) - 1) & ((2 << n) - 1)
这个通过平方求幂来计算多项式环Z [X] /（X ^ 2 - X - 1）中的X ^ n。该计算的结果是多项式Fib（n）X + Fib（n-1），从中可以读取第n个Fibonacci数。
同样，这使用O（log n）算术运算并且非常有效。
def mul(a, b):
return a[0]*b[1]+a[1]*b[0]+a[0]*b[0], a[0]*b[0]+a[1]*b[1]
def fib(n):
x, r = (1, 0), (0, 1)
while n:
if n & 1: r = mul(r, x)
x = mul(x, x)
n >>= 1
return r[0]
答案 5 :(得分：6)
用于打印Fibonacci序列的Canonical Python代码：
a,b=1,1
while True:
print a,
a,b=b,a+b # Could also use b=a+b;a=b-a
对于问题“打印长度大于1000位的第一个Fibonacci数字”：
a,b=1,1
i=1
while len(str(a))<=1000:
i=i+1
a,b=b,a+b
print i,len(str(a)),a
答案 6 :(得分：3)
我们知道
那个矩阵的n次幂给了我们：
因此我们可以实现一个函数，只需将该矩阵的幂计算为第n -1次幂。
因为我们都知道功率a ^ n等于
所以最后斐波纳契函数将是O（n）......如果不是因为我们也知道x^n * x^n = x^2n和{{{}的评价，那么没有什么真正不同于更简单的实现因此，可以使用复杂度O（log n）
这是我使用swift编程语言实现的斐波纳契实现：
x^n这具有复杂度O（log n）。我们用指数n-1计算Q的幂，然后我们得到元素m00，它是Fn + 1，在幂指数n-1处恰好是我们想要的第n个Fibonacci数。
一旦你有了快速的fibonacci函数，你可以从起始编号和结束编号迭代，得到你感兴趣的Fibonacci序列的一部分。
struct Mat {
var m00: Int
var m01: Int
var m10: Int
var m11: Int
}
func pow(m: Mat, n: Int) -> Mat {
guard n > 1 else { return m }
let temp = pow(m: m, n: n/2)
var result = matMultiply(a: temp, b: temp)
if n%2 != 0 {
result = matMultiply(a: result, b: Mat(m00: 1, m01: 1, m10: 1, m11: 0))
}
return result
}
func matMultiply(a: Mat, b: Mat) -> Mat {
let m00 = a.m00 * b.m00 + a.m01 * b.m10
let m01 = a.m00 * b.m01 + a.m01 * b.m11
let m10 = a.m10 * b.m00 + a.m11 * b.m10
let m11 = a.m10 * b.m01 + a.m11 * b.m11
return Mat(m00: m00, m01: m01, m10: m10, m11: m11)
}
func fibonacciFast(n: Int) -> Int {
guard n > 0 else { return 0 }
let m = Mat(m00: 1, m01: 1, m10: 1, m11: 0)
return pow(m: m, n: n-1).m00
}
当然首先在开始和结束时执行一些检查，以确保它们可以形成有效范围。
我知道这个问题是8岁，但无论如何我都很乐意回答。 ：）
答案 7 :(得分：3)
使用递归：
def fib(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return fib(n-1) + fib(n-2)
x=input('which fibonnaci do you want?')
print fib(x)
答案 8 :(得分：2)
def fib(n):
a = 0
b = 1
for i in range(1,n+1):
c = a + b
print b
a = b
b = c
代码应该打印b而不是打印c
输出：1,1,2,3,5 ......
答案 9 :(得分：2)
import time
start_time = time.time()
#recursive solution
def fib(x, y, upperLimit):
return [x] + fib(y, (x+y), upperLimit) if x < upperLimit else [x]
#To test :
print(fib(0,1,40000000000000))
print("run time: " + str(time.time() - start_time))
结果
[0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711， 28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986,102325155,165580141,267914296,43349437,701408733,1344903170,1836311903,2971215073， 4807526976，7778742049，12586269025，20365011074，32951280099，53316291173，86267571272，139583862445，225851433717，365435296162，591286729879，956722026041，1548008755920，2504730781961，4052739537881，6557470319842，10610209857723，17167680177565，27777890035288，44945570212853]
运行时间： 0.04298138618469238
答案 10 :(得分：2)
使用for循环并仅打印结果
def fib(n:'upto n number')->int:
if n==0:
return 0
elif n==1:
return 1
a=0
b=1
for i in range(0,n-1):
b=a+b
a=b-a
return b
结果
>>>fib(50)
12586269025
>>>>
>>> fib(100)
354224848179261915075
>>>
打印包含所有数字的list
def fib(n:'upto n number')->int:
l=[0,1]
if n==0:
return l[0]
elif n==1:
return l
a=0
b=1
for i in range(0,n-1):
b=a+b
a=b-a
l.append(b)
return l
结果
>>> fib(10)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
答案 11 :(得分：2)
有一种非常简单的方法可以实现这一点！
您可以使用http://www.learnpython.org/
自由在线运行此代码# Set the variable brian on line 3!
def fib(n):
"""This is documentation string for function. It'll be available by fib.__doc__()
Return a list containing the Fibonacci series up to n."""
result = []
a = 0
b = 1
while a < n:
result.append(a) # 0 1 1 2 3 5 8 (13) break
tmp_var = b # 1 1 2 3 5 8 13
b = a + b # 1 2 3 5 8 13 21
a = tmp_var # 1 1 2 3 5 8 13
# print(a)
return result
print(fib(10))
# result should be this: [0, 1, 1, 2, 3, 5, 8]
答案 12 :(得分：2)
好的..在厌倦了所有冗长的答案之后，现在找到以下排序＆amp;在python中实现Fibonacci的甜蜜，非常直接的方式。您可以通过获取参数或获取用户输入来改进它，或者从10000更改限制。根据需要......
def fibonacci():
start = 0
i = 1
lt = []
lt.append(start)
while start < 10000:
start += i
lt.append(start)
i = sum(lt[-2:])
lt.append(i)
print "The Fibonaccii series: ", lt
这种方法也表现良好。找到下面的运行分析
In [10]: %timeit fibonacci
10000000 loops, best of 3: 26.3 ns per loop
答案 13 :(得分：2)
def fib():
a,b = 1,1
num=eval(input("Please input what Fib number you want to be calculated: "))
num_int=int(num-2)
for i in range (num_int):
a,b=b,a+b
print(b)
答案 14 :(得分：2)
这些看起来都比他们需要的要复杂得多。 我的代码非常简单快捷：
def fibonacci(x):
List = []
f = 1
List.append(f)
List.append(f) #because the fibonacci sequence has two 1's at first
while f<=x:
f = List[-1] + List[-2] #says that f = the sum of the last two f's in the series
List.append(f)
else:
List.remove(List[-1]) #because the code lists the fibonacci number one past x. Not necessary, but defines the code better
for i in range(0, len(List)):
print List[i] #prints it in series form instead of list form. Also not necessary
答案 15 :(得分：2)
另一种方法：
a,n=[0,1],10
map(lambda i: reduce(lambda x,y: a.append(x+y),a[-2:]),range(n-2))
将列表分配给'a'，将整数分配给'n' Map和reduce是python中三个最强大的函数中的两个。这里map仅用于迭代'n-2'次。 a [-2：]将获得数组的最后两个元素。 a.append（x + y）将添加最后两个元素并将附加到数组
答案 16 :(得分：1)
递归增加了时间。要消除循环，请先import math。然后在函数中使用math.sqrt和黄金比例：
#!/usr/bin/env python3
import math
def fib(n):
gr = (1 + math.sqrt(5)) / 2
fib_first = (gr**n - (1 - gr)**n) / math.sqrt(5)
return int(round(fib_first))
fib_final = fib(100)
print(fib_final)
答案 17 :(得分：1)
使用append函数生成前100个元素。
def generate():
series = [0, 1]
for i in range(0, 100):
series.append(series[i] + series[i+1])
return series
print(generate())
答案 18 :(得分：1)
对于Fibonacci系列，这是python中最简单的一个，但是通过append（）在输出数组中调整[0]，得到结果列表第二个变量result.append(second)
def fibo(num):
first = 0
second = 1
result = [0]
print('Fibonacci series is')
for i in range(0,num):
third = first + second
#print(second)
result.append(second)
first = second
second = third
print(result)
return
fibo(7)
输出
Fibonacci series is
[0, 1, 1, 2, 3, 5, 8, 13]
答案 19 :(得分：1)
Fibonacci序列是：1, 1, 2, 3, 5, 8, ...。
那是f(1) = 1，f(2) = 1，f(3) = 2，...，f(n) = f(n-1) + f(n-2)。
我最喜欢的实现（最简单但与其他实现相比实现轻快）是：
def fibonacci(n):
a, b = 0, 1
for _ in range(1, n):
a, b = b, a + b
return b
<强>测试
>>> [fibonacci(i) for i in range(1, 10)]
[1, 1, 2, 3, 5, 8, 13, 21, 34]
<强>时序
>>> %%time
>>> fibonacci(100**3)
CPU times: user 9.65 s, sys: 9.44 ms, total: 9.66 s
Wall time: 9.66 s
编辑：an example visualization用于此实施。
答案 20 :(得分：1)
只是为了好玩，在Python 3.8+中，您可以在列表理解中使用assignment expression（又称海象运算符），例如：
>>> a, b = 0, 1
>>> [a, b] + [b := a + (a := b) for _ in range(8)] # first 10 Fibonacci numbers
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
赋值表达式使您可以将值赋给变量 ，并在同一表达式中返回它。因此，表达式
b := a + (a := b)
等同于执行
a, b = b, a + b
并返回b的值。
答案 21 :(得分：1)
def fib(lowerbound, upperbound):
x = 0
y = 1
while x <= upperbound:
if (x >= lowerbound):
yield x
x, y = y, x + y
startNumber = 10
endNumber = 100
for fib_sequence in fib(startNumber, endNumber):
print "And the next number is... %d!" % fib_sequence
答案 22 :(得分：1)
基本上是从Ruby翻译过来的：
def fib(n):
a = 0
b = 1
for i in range(1,n+1):
c = a + b
print c
a = b
b = c
...
答案 23 :(得分：1)
如果您不知道斐波那契数列是什么，那么基本上您会打印出一个数字，并且您打印出的每个数字都是前两个数字相加。
a, b = 0,1
for i in range(0, 10):
print(a)
a, b = b, a + b
输出：
0
1
1
2
3
5
8
13
21
34
所以 0 和 1 如果你把它们加在一起它等于 1 如果你加 1 和 1 它等于 2 如果你加 1 和 2 它等于 3 并且它继续前进并继续前进。
此处我使用生成器编写的斐波那契数列：
def fib(num):
a, b = 0,1
for i in range(0, num):
yield "{}: {}".format(i+1, a)
a, b = b, a + b
for item in fib(10):
print(item)
输出：
1: 0
2: 1
3: 1
4: 2
5: 3
6: 5
7: 8
8: 13
9: 21
10: 34
我们之前讨论过的斐波那契数列，但现在我们有一个函数 yields 和 yield 是关键字，让您知道它是一个生成器。
- 因此，它会产生您的结果，然后我们可以遍历生成器并打印出每个项目。
- 如果我们运行，那么我们可以看到它仍然像以前一样工作，但是现在我们使用生成器代替它比返回列表有更多的优势，但是有时您不想使用生成器.
- 您需要进行研究，弄清楚您何时真正从生成器中获得了这些优势，以及何时它们可能不是您的最佳选择。
答案 24 :(得分：0)
嗯，有很多方法。我已经使用列表来解决此问题。.下面是工作代码...如果有任何反馈，请随时发表评论
Lemma f_2: f 2 = 4.
Proof.
unfold f; cbn.
change 4 with (2 * 2).
rewrite Rmult_1_r.
reflexivity.
Qed.
答案 25 :(得分：0)
基于经典的斐波纳契序列，仅仅是为了单行
如果您只需要索引编号，则可以使用reduce （即使减少它不适合这个，这可能是一个很好的练习）
def fibonacci(index):
return reduce(lambda r,v: r.append(r[-1]+r[-2]) or (r.pop(0) and 0) or r , xrange(index), [0, 1])[1]
并获取完整数组只需删除或（r.pop（0）和0）
reduce(lambda r,v: r.append(r[-1]+r[-2]) or r , xrange(last_index), [0, 1])
答案 26 :(得分：0)
def fib(n):
"""
n >= 1, the number of elements in the Fibonacci sequence
"""
x, y = 0, 1
for i in range(n):
yield x
x, y = y, x + y
答案 27 :(得分：0)
如果您喜欢递归，可以使用lru_cache装饰器（最近使用的高速缓存装饰器）轻松地缓存结果
from functools import lru_cache
@lru_cache()
def fib(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return fib(n-1) + fib(n-2)
如果您需要缓存128个以上的值，则可以将maxsize作为参数传递给lru_cache（例如lru_cache(maxsize=500)。如果设置maxsize=None，则缓存可以增长不受限制。
答案 28 :(得分：0)
以pythonic方式，您可以通过以下方法编写fibannoic系列：
a,b = 0,1
while b < 1000:
b = (b, end = ' ', flush = True)
a,b = b , a+b
答案 29 :(得分：0)
可以通过以下方式完成。
n = 0
numbers = [0]
for i in range(0,11):
print n,
numbers.append(n)
prev = numbers[-2]
if n == 0:
n = 1
else:
n = n + prev
答案 30 :(得分：0)
简单的Fibo：
def fibo(start, count):
a = [start, start+1]
for i in range(count-len(a)):
a.append(a[-1]+a[-2])
return a
a = fibo(0, 10)
print 'fibo', a
输出： [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
写为生成器的斐波那契
# fill in this function
def fib():
a = 1
b = 1
yield(a)
yield(b)
for i in range(2, 10):
c = a+b
a, b = b, c
yield(c)
#pass #this is a null statement which does nothing when executed, useful as a placeholder.
# testing code
import types
if type(fib()) == types.GeneratorType:
print("Good, The fib function is a generator.")
counter = 0
for n in fib():
print(n)
counter += 1
if counter == 10:
break
答案 31 :(得分：0)
采用短得多的格式：
def fibbo(range_, a, b):
if(range_!=0):
a, b = b, a+b
print(a)
return fibbo(range_-1, a, b)
return
fibbo(11, 1, 0)
答案 32 :(得分：0)
简单的斐波那契数列：
val result = itemsSingle.map { items->
Type.values().associateWith { listOf<Item>() } + items.groupBy { it.type }
}
答案 33 :(得分：0)
通过将列表保留在内存中来发现斐波那契的优化功能
def fib(n, a=[0, 1]):
while n > len(a):
a.append(a[-1] + a[-2])
return a[n-1]
print("Fibonacci of 50 - {}".format(fib(50))
答案 34 :(得分：0)
我在学习Python时使用的教程15分钟，它要求读者编写一个程序，该程序将根据3个输入数字计算Fibonacci序列（第一个Fibonacci数，第二个数和停止序列的数字）。该教程仅涵盖了变量，if / thens和循环到那一点。还没有功能。我想出了以下代码：
sum = 0
endingnumber = 1
print "\n.:Fibonacci sequence:.\n"
firstnumber = input("Enter the first number: ")
secondnumber = input("Enter the second number: ")
endingnumber = input("Enter the number to stop at: ")
if secondnumber < firstnumber:
print "\nSecond number must be bigger than the first number!!!\n"
else:
while sum <= endingnumber:
print firstnumber
if secondnumber > endingnumber:
break
else:
print secondnumber
sum = firstnumber + secondnumber
firstnumber = sum
secondnumber = secondnumber + sum
正如您所看到的，它效率非常低，但它确实有效。
答案 35 :(得分：0)
通过http://projecteuler.net/problem=2这是我对它的看法
# Even Fibonacci numbers
# Problem 2
def get_fibonacci(size):
numbers = [1,2]
while size > len(numbers):
next_fibonacci = numbers[-1]+numbers[-2]
numbers.append(next_fibonacci)
print numbers
get_fibonacci(20)
答案 36 :(得分：0)
def fib(x, y, n):
if n < 1:
return x, y, n
else:
return fib(y, x + y, n - 1)
print fib(0, 1, 4)
(3, 5, 0)
#
def fib(x, y, n):
if n > 1:
for item in fib(y, x + y, n - 1):
yield item
yield x, y, n
f = fib(0, 1, 12)
f.next()
(89, 144, 1)
f.next()[0]
55
答案 37 :(得分：0)
我试图避免使用递归函数来解决这个问题，所以我采用了迭代方法。我最初做了一个memoized递归函数，但仍然保持最大的递归深度。我也有严格的内存目标，所以你会看到我在循环过程中保持数组尽可能小，只在数组中保留2-3个值。
def fib(n):
fibs = [1, 1] # my starting array
for f in range(2, n):
fibs.append(fibs[-1] + fibs[-2]) # appending the new fib number
del fibs[0] # removing the oldest number
return fibs[-1] # returning the newest fib
print(fib(6000000))
在我的机器上获得第600万个斐波那契数字大约需要282秒，而600k斐波那契只需要2.8秒。我无法使用递归函数获得如此大的斐波纳契数，即使是记忆函数也是如此。
答案 38 :(得分：0)
关于Memoization如何为Fibonacci序列工作的更详细解释。
{{1}}
答案 39 :(得分：0)
也许这会有所帮助
def fibo(n):
result = []
a, b = 0, 1
while b < n:
result.append(b)
a, b = b, b + a
return result
答案 40 :(得分：0)
这个怎么样？我想它并不像其他建议那样花哨，因为它需要先前结果的初始规范才能产生预期的输出，但我觉得这是一个非常易读的选项，即它所做的就是提供结果和之前的结果递归。
#count the number of recursions
num_rec = 0
def fibonacci(num, prev, num_rec, cycles):
num_rec = num_rec + 1
if num == 0 and prev == 0:
result = 0;
num = 1;
else:
result = num + prev
print(result)
if num_rec == cycles:
print("done")
else:
fibonacci(result, num, num_rec, cycles)
#Run the fibonacci function 10 times
fibonacci(0, 0, num_rec, 10)
这是输出：
0
1
1
2
3
5
8
13
21
34
done
答案 41 :(得分：0)
试试这个：
def nth_fib(n):
if n == 0:
return 1
elif n == 1:
return 0
else:
return nth_fib(n - 1) + nth_fib(n - 2)
答案 42 :(得分：-1)
通过调用函数并进行模块化来实现此解决方案
def userInput():
number = int(input('Please enter the number between 1 - 40 to find out the
fibonacci :'))
return number
def findFibonacci(number):
if number == 0:
return 0
elif number == 1:
return 1
else:
return findFibonacci(number - 1) + findFibonacci (number - 2)
def main():
userNumber = userInput()
print(findFibonacci(userNumber))
main()
答案 43 :(得分：-1)
简单的定义-试试这个。.
def fib(n):
first = 0
second = 1
holder = 0
array = []
for i in range(0, n):
first = second
second = holder
holder = first + second
array.append(holder)
return array
input -> 10
output -> [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
答案 44 :(得分：-1)
这与已发布的相似，但它干净，快速且易于阅读。
String#split()答案 45 :(得分：-1)
# num is the number up to which your list will go
#first I created a list, and I wanted to code #everything, but obviously, I could have typed l = [0,1]
def fab(num):
l = []
for k in range(0,2):
l.append(k)
while l[-1]<num:
x = l[-1]+l[-2]
if x>=num:
break
else:
l.append(x)
return l
答案 46 :(得分：-1)
Python中的斐波那契数列，通过创建空列表：
inp=int(input()) #size of the series example it is 7
n=0
n1=1
x=[] #blank list
x.insert(0,0) #initially insert 0th position 0 element
for i in range(0,inp-1):
nth=n+n1
n=n1 #swapping the value
n1=nth
x.append(n) #append all the values to null list
for i in x: #run this loop so ans is 0 1 1 2 3 5 8
print(i,end=" ")
答案 47 :(得分：-4)
你们能检查一下吗，我认为它很棒而且易于理解。
i = 0
First_Value = 0
Second_Value = 1
while(i < Number):
if(i <= 1):
Next = i
else:
Next = First_Value + Second_Value
First_Value = Second_Value
Second_Value = Next
print(Next)
i = i + 1
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？