152

我最初对程序进行了错误的编码。我没有返回一个范围之间的斐波那契数(即 startNumber 1,endNumber 20 应该 = 仅那些介于 1 和 20 之间的数字),而是为程序编写了显示范围之间的所有斐波那契数(即 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 序列论坛,但我也迷失了方向。

4

47 回答 47

274

在wikipediawolfram上有很多关于斐波那契数列的信息。比您可能需要的多得多。无论如何,学习如何使用这些资源来找到(如果可能的话,尽快)你需要的东西是一件好事。

将 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))

另一种方法是遵循定义(来自维基百科):

序列的第一个数字是 0,第二个数字是 1,随后的每个数字都等于序列本身的前两个数字之和,产生序列 0、1、1、2、3、5、8 , ETC。

如果您的语言支持迭代器,您可以执行以下操作:

def F():
    a,b = 0,1
    while True:
        yield a
        a, b = b, a + b

仅从 Fib 序列显示 startNumber 到 endNumber。

一旦您知道如何生成斐波那契数列,您只需要循环遍历这些数字并检查它们是否验证了给定的条件。

假设现在您编写了 af(n),它返回斐波那契数列的第 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

我的提示是学会阅读你需要的东西。Project Euler(谷歌)会训练你这样做:P祝你好运,玩得开心!

于 2009-01-31T18:01:14.377 回答
78

斐波那契数列的高效 Pythonic 生成器

我在尝试获得该序列的最短 Pythonic 生成时发现了这个问题(后来意识到我在Python Enhancement Proposal中看到过类似的问题),并且我没有注意到其他人提出了我的具体解决方案(尽管最佳答案很接近,但仍然不那么优雅),所以在这里,带有描述第一次迭代的评论,因为我认为这可能有助于读者理解:

def fib():
    a, b = 0, 1
    while True:            # First iteration:
        yield a            # yield 0 to start with and then
        a, b = b, a + b    # a will now be 1, and b will also be 1, (0 + 1)

和用法:

for index, fibonacci_number in zip(range(10), fib()):
     print('{i:3}: {f:3}'.format(i=index, f=fibonacci_number))

印刷:

  0:   0
  1:   1
  2:   1
  3:   2
  4:   3
  5:   5
  6:   8
  7:  13
  8:  21
  9:  34
 10:  55

(出于归因的目的,我最近注意到Python 文档中关于模块的类似实现a,即使使用变量和b,我现在记得在写这个答案之前已经看到过。但我认为这个答案展示了更好地使用语言。)

递归定义的实现

整数序列在线百科全书将斐波那契数列递归定义为

F(n) = F(n-1) + F(n-2) 其中 F(0) = 0 且 F(1) = 1

在 Python 中简洁地递归定义 this 可以如下完成:

def rec_fib(n):
    '''inefficient recursive function as defined, returns Fibonacci number'''
    if n > 1:
        return rec_fib(n-1) + rec_fib(n-2)
    return n

但是这种数学定义的精确表示对于远大于 30 的数字来说是非常低效的,因为每个被计算的数字还必须计算它下面的每个数字。您可以使用以下方法演示它有多慢:

for i in range(40):
    print(i, rec_fib(i))

记忆递归提高效率

它可以被记忆以提高速度(这个例子利用了这样一个事实,即每次调用函数时默认关键字参数都是同一个对象,但通常你不会因为这个原因而使用可变的默认参数):

def mem_fib(n, _cache={}):
    '''efficiently memoized recursive function, returns a Fibonacci number'''
    if n in _cache:
        return _cache[n]
    elif n > 1:
        return _cache.setdefault(n, mem_fib(n-1) + mem_fib(n-2))
    return n

你会发现记忆的版本要快得多,并且会在你想起来喝咖啡之前迅速超过你的最大递归深度。通过执行以下操作,您可以直观地看到它的速度有多快:

for i in range(40):
    print(i, mem_fib(i))

(看起来我们可以做下面的事情,但它实际上并没有让我们利用缓存,因为它在调用 setdefault 之前调用了自己。)

def mem_fib(n, _cache={}):
    '''don't do this'''
    if n > 1:  
        return _cache.setdefault(n, mem_fib(n-1) + mem_fib(n-2))
    return n

递归定义的生成器:

由于我一直在学习 Haskell,我在 Haskell 中遇到了这个实现:

fib@(0:tfib) = 0:1: zipWith (+) fib tfib

我认为目前在 Python 中最接近这一点的是:

from itertools import tee

def fib():
    yield 0
    yield 1
    # tee required, else with two fib()'s algorithm becomes quadratic
    f, tf = tee(fib()) 
    next(tf)
    for a, b in zip(f, tf):
        yield a + b

这证明了这一点:

[f for _, f in zip(range(999), fib())]

但是,它只能达到递归限制。通常是 1000,而 Haskell 版本可以达到数百万,尽管它使用了我笔记本电脑的全部 8 GB 内存来做到这一点:

> length $ take 100000000 fib 
100000000

使用迭代器获取第 n 个斐波那契数

一位评论者问:

基于迭代器的 Fib() 函数的问题:如果你想获得第 n 个,例如第 10 个 fib 编号怎么办?

itertools 文档对此有一个秘诀:

from itertools import islice

def nth(iterable, n, default=None):
    "Returns the nth item or a default value"
    return next(islice(iterable, n, None), default)

现在:

>>> nth(fib(), 10)
55
于 2014-07-20T02:24:24.543 回答
27

为什么不简单地执行以下操作?

x = [1,1]
for i in range(2, 10):  
    x.append(x[-1] + x[-2]) 
print(', '.join(str(y) for y in x))
于 2014-02-11T14:34:53.603 回答
22

斐波那契数列背后的思想显示在以下 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) 的定义来计算的。像斐波那契函数那样调用自己的函数称为递归,它是编程中的一个重要主题。

这听起来像是一个家庭作业,所以我不会为你做开始/结束部分。尽管如此,Python 是一种极富表现力的语言,所以如果你理解数学,这应该是有意义的,并且希望能教你递归。祝你好运!

编辑:对我的代码的一个潜在批评是它没有使用超级方便的 Python 函数 yield,这使得 fib(n) 函数更短。不过,我的示例更通用一些,因为 Python 之外的许多语言实际上都没有产量。

于 2009-01-30T06:15:45.237 回答
13

时间复杂度:

缓存功能通过消除斐波那契数列递归树中的重复,将计算斐波那契数列的正常方法从O(2^n)减少到O(n) :

在此处输入图像描述

代码 :

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()
于 2014-09-30T10:14:59.723 回答
10

这非常有效,使用 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)

这个计算 X^n 在多项式环 Z[X] / (X^2 - X - 1) 中使用平方取幂。该计算的结果是多项式 Fib(n)X + Fib(n-1),从中可以读取第 n 个斐波那契数。

同样,这使用 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]
于 2016-06-02T07:47:03.287 回答
6

用于打印斐波那契数列的规范 Python 代码:

a,b=1,1
while True:
  print a,
  a,b=b,a+b       # Could also use b=a+b;a=b-a

对于“打印第一个大于 1000 位的斐波那契数”问题:

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
于 2014-02-06T15:39:57.527 回答
4

我们知道

在此处输入图像描述

该矩阵的 n 次方为我们提供:

在此处输入图像描述

所以我们可以实现一个函数,简单地计算该矩阵的 n 次 -1 次幂。

众所周知,a^n 的幂等于

在此处输入图像描述

所以最后斐波那契函数将是 O(n)……如果不是因为我们也知道这一点,那么与更简单的实现没有什么不同,x^n * x^n = x^2n因此x^n可以用复杂度 O(log n )

这是我使用 swift 编程语言的斐波那契实现:

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
}

这具有复杂性 O( log n )。我们用指数 n-1 计算 Q 的 oì 幂,然后我们取元素 m00 ,它是 Fn+1 ,在幂指数 n-1 处正是我们想要的第 n 个斐波那契数。

一旦你有了快速斐波那契函数,你就可以从开始数和结束数迭代得到你感兴趣的斐波那契数列部分。

let sequence = (start...end).map(fibonacciFast)

当然首先对开始和结束进行一些检查,以确保它们可以形成一个有效的范围。

我知道这个问题已经有 8 年的历史了,但无论如何我回答都很开心。:)

于 2018-01-26T10:45:27.770 回答
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)
于 2013-04-11T13:53:43.343 回答
3

斐波那契数列是: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

编辑:此实现的示例可视化。

于 2016-03-14T09:33:26.497 回答
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) 将添加最后两个元素并将追加到数组

于 2014-02-07T06:05:27.013 回答
2

如果您喜欢递归,您可以使用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缓存可以无限制地增长。

于 2019-06-07T14:21:42.760 回答
1

这些看起来都比他们需要的要复杂一些。我的代码非常简单快速:

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
于 2014-02-02T04:59:00.810 回答
1

好的..在厌倦了所有冗长的答案之后,现在找到下面的排序和甜蜜,非常直接的方式来在 python 中实现斐波那契。您可以通过获取参数或获取用户输入以您想要的方式对其进行增强……或将限制从 10000 更改。根据需要……</p>

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
于 2015-11-01T04:35:36.870 回答
1

这是对 mathew henry 答案的改进:

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 ....

于 2016-09-01T17:21:27.160 回答
1

有一个非常简单的方法来实现这一点!

您可以使用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]
于 2016-09-21T09:48:48.033 回答
1

使用 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]
于 2016-11-04T16:11:18.867 回答
1
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,102334155,165580141,267914296,433494437,701408733,1134903170,1836311903,2971215073,4807526976,7778742049 ,12586269025,20365011074,32951280099,53316291173,86267571272,139583862445,225851433717,365435296162,591286729879,956722026041,1548008755920,2504730781961,4052739537881,6557470319842,10610209857723,17167680177565,27777890035288,44945570212853]

运行时间:0.04298138618469238

于 2016-11-22T04:39:18.090 回答
1

优化内存查找斐波那契功能

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))
于 2018-01-09T06:50:21.163 回答
1

可以通过以下方式完成。

n = 0

数字 = [0]

对于范围内的我(0,11):
    打印 n,
    numbers.append(n)
    上一页 = 数字[-2]
    如果 n == 0:
        n = 1
    别的:
        n = n + 上一个
于 2019-05-17T11:29:10.500 回答
1

只是为了好玩,在 Python 3.8+ 中,您可以在列表理解中使用赋值表达式(又名海象运算符),例如:

>>> 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

于 2019-11-30T16:24:51.300 回答
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是让您知道它是生成器的关键字。

  • 因此,它会产生您的结果,然后我们可以遍历生成器并打印出每个项目。
  • 如果我们运行,那么我们可以看到它仍然像以前一样工作,但是现在我们使用生成器,它比返回列表更有优势,但是有时你不想使用生成器。
  • 你需要做你的研究,弄清楚什么时候你真的从发电机那里获得了这些优势,什么时候它们可能不是你的最佳选择。
于 2021-01-09T19:50:21.163 回答
0
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)
于 2011-06-27T20:42:31.413 回答
0

在我学习 Python 时使用的教程 15 分钟后,它要求读者编写一个程序,该程序将根据 3 个输入数字(第一个斐波那契数字、第二个数字和停止序列的数字)计算斐波那契数列。本教程仅涵盖了变量、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

如您所见,它确实效率低下,但确实有效。

于 2011-10-24T07:53:33.303 回答
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)
于 2013-09-12T11:53:24.797 回答
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
于 2013-11-24T01:09:50.820 回答
0

也许这会有所帮助

def fibo(n):
    result = []
    a, b = 0, 1
    while b < n:
            result.append(b)
            a, b = b, b + a
    return result
于 2014-03-07T19:11:55.797 回答
0

基于经典的斐波那契数列,只是为了单线

如果你只需要索引的数量,你可以使用reduce(即使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]

要获得完整的数组,只需删除or (r.pop(0) and 0)

reduce(lambda r,v: r.append(r[-1]+r[-2]) or r , xrange(last_index), [0, 1])
于 2015-02-11T18:01:18.047 回答
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
于 2015-02-22T14:58:04.753 回答
0

基本上是从 Ruby 翻译过来的:

def fib(n):
    a = 0
    b = 1
    for i in range(1,n+1):
            c = a + b
            print c
            a = b
            b = c

...

于 2015-10-22T23:09:13.970 回答
0
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
于 2015-11-12T19:29:58.330 回答
0

更详细地解释了记忆化如何适用于斐波那契数列。

# Fibonacci sequence Memoization

fib_cache = {0:0, 1:1}

def fibonacci(n):
    if n < 0:
        return -1
    if fib_cache.has_key(n):
        print "Fibonacci sequence for %d = %d cached" % (n, fib_cache[n])
        return fib_cache[n]
    else:
        fib_cache[n] = fibonacci(n - 1) + fibonacci(n - 2)
    return fib_cache[n]

if __name__ == "__main__":
    print fibonacci(6)
    print fib_cache
    # fibonacci(7) reuses fibonacci(6) and fibonacci(5)
    print fibonacci(7)
    print fib_cache
于 2015-12-17T06:47:27.117 回答
0

我试图避免使用递归函数来解决这个问题,所以我采用了迭代方法。我最初是在做一个记忆递归函数,但一直在达到最大递归深度。我也有严格的内存目标,所以你会看到我在循环过程中尽可能小地保持数组,只在数组中随时保留 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))

在我的机器上获得第 6 百万个斐波那契数大约需要 282 秒,而 600k 斐波那契数只需要 2.8 秒。我无法使用递归函数获得如此大的斐波那契数,即使是记忆函数也是如此。

于 2015-12-31T05:51:31.470 回答
0

递归增加了时间。要消除循环,首先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)

参考:Python 中的斐波那契数列

于 2016-08-29T20:23:11.717 回答
0

这是用于斐波那契数列的 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]
于 2017-05-17T08:24:28.340 回答
0

使用 append 函数生成前 100 个元素。

def generate():
    series = [0, 1]
    for i in range(0, 100):
        series.append(series[i] + series[i+1])

    return series


print(generate())
于 2017-09-21T18:57:27.377 回答
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)
于 2018-09-01T21:57:38.533 回答
0

通过调用函数和模块化来做这个解决方案

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() 
于 2018-10-10T17:16:04.203 回答
0

简单斐波那契:

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
于 2019-01-17T06:01:19.477 回答
0

好吧,有很多方法。我已经使用列表来解决这个问题。下面是工作代码...如果有任何反馈,请随时发表评论

def fib(n):
    if n == 0: #to start fibonacci seraries value must be >= 1
        print('Enter postive integer')
    elif n ==1:
        print(0)
    else:
        li = [0, 1]
        for i in range(2, n): # start the loop from second index as 'li' is assigned for 0th and 1st index
            li.append(li[-1] + li[-2])
            i += 1
        print(*li)  # '*' is used to print elements from list in single line with spaces

n = int(input('Enter the number for which you want to generate fibonacci series\n'))
fib(n)
于 2020-05-01T12:14:58.260 回答
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
于 2020-08-16T13:43:14.173 回答
0

简单的斐波那契数列:

def fib(x):
    b = 1
    c = 0
    print(0)
    for i in range(x - 1):
        a = b
        b = c
        c = a + b
        print(c)
于 2021-08-02T18:24:12.450 回答
-1

这与已发布的内容相似,但它干净、快速且易于阅读。

def fib(n):
# start with first two fib numbers
fib_list = [0, 1]
i = 0
# Create loop to iterate through n numbers, assuming first two given
while i < n - 2:
    i += 1
    # append sum of last two numbers in list to list
    fib_list.append(fib_list[-2] + fib_list[-1])
return fib_list
于 2017-11-21T03:55:25.220 回答
-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]
于 2018-12-30T03:46:09.273 回答
-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
于 2019-04-02T15:21:59.183 回答
-2

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=" ")
于 2020-01-10T09:21:17.903 回答
-5

你们能看看这个吗,我认为它很棒而且很容易理解。

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
于 2019-05-12T17:39:42.983 回答