斐波那契数列在Python中的变化

Question

我正在研究Python中的递归，现在这个练习遇到了问题：

请记住，斐波那契数列是一个数字序列，其中每个数字都是前两个数字的和。

对于此问题，请以递归方式递归实现Fibonacci！ 假设我们要创建一个称为Fibonacci-3的新数字序列。 在斐波那契3中，序列中的每个数字都是前三个数字的总和。 该序列将从三个1开始，因此第四个Fibonacci-3数字将为3（1 + 1 + 1），第五个将为5（1 + 1 + 3），第六个将为9（1 + 3 + 5） ），则第七个为17（3 + 5 + 9），依此类推。

将函数命名为fib3，并确保使用递归。

下面的行将测试您的代码。

如果你的函数是正确的，他们将打印1，3，17，和57。

 print(fib3(3)) print(fib3(4)) print(fib3(7)) print(fib3(9)) 

这是到目前为止的代码：

def fib3(n):
    if n <= 1:
        return n
    else:
        return(fib3(n-1) + fib3(n-2) + fib3(n-3))

但是结果是：1，2，11，37

你能帮我改正吗？

Answer 1

别人在说同样的话

正如其他人指出的那样，当n <= 3时，您必须返回1

def fib3 (n):
  if n <= 3:
    return 1
  else:
    return fib3(n - 1) + fib3(n - 2) + fib3(n - 3)

print(fib3(3)) # 1
print(fib3(4)) # 3
print(fib3(7)) # 17
print(fib3(9)) # 57

...但是你可以做得更好

但是fib3定义是垃圾。 它的计算重复的疯狂量。 例如，由于O（n ³ ）的复杂性， fib3(40)花费了30分钟以上的时间进行计算

考虑一种使用带有状态变量的辅助循环的方法– O（n）的复杂度使其可以在不到一毫秒的时间内计算出相同的结果。

def fib3 (n):
  def aux (n,a,b,c):
    if n == 1:
      return a
    else:
      return aux(n-1,b,c,a+b+c)
  return aux(n,1,1,1)

print(fib3(3))  # 1
print(fib3(4))  # 3
print(fib3(7))  # 17
print(fib3(9))  # 57
print(fib3(40)) # 9129195487

---

斐波那契作为通用程序： fibx

我们可以使生成斐波那契序列的整个过程通用化，但是首先我们必须使用fib3函数来解决某些问题。 通常， 斐波那契数具有第0项-即， fib(0) == 0 ， fib(1) == 1 。 在您的函数中，第一个数字似乎是fib3(1) ，其中fib3(0)将产生未定义的结果。

下面，我将介绍fibx ，它可以使用任何二进制运算符和任何种子值，并创建我们可以想象的任何fibonacci序列

from functools import reduce

def fibx (op, seed, n):
  [x,*xs] = seed
  if n == 0:
    return x
  else:
    return fibx(op, xs + [reduce(op, xs, x)], n - 1)

现在我们可以使用带有添加（ + ）运算符和种子值0,1的fibx实现标准的斐波那契

from operator import add

def fib (n):
  return fibx(add, [0,1], n)

print(fib(0)) # 0
print(fib(1)) # 1
print(fib(2)) # 1
print(fib(3)) # 2
print(fib(4)) # 3
print(fib(5)) # 5

实施fib3使用fibx

我们可以使用与add运算符相同的fibx来实现fib3函数，但是由于基于1的索引，请注意，我将n偏移1以获取正确的输出

from operator import add

def fib3 (n):
  return fibx(add, [1,1,1], n-1)

print(fib3(3)) # 1
print(fib3(4)) # 3
print(fib3(7)) # 17
print(fib3(9)) # 57

我建议您从基于0的索引开始。 这意味着从0开始的索引fib3(2)实际上等于从1开始的索引fib3(3)

from operator import add

def fib3 (n):
  return fibx(add, [1,1,1], n)

print(fib3(2)) # 1
print(fib3(3)) # 3
print(fib3(6)) # 17
print(fib3(8)) # 57

使用fibx任何可想象的序列

当然，您还可以做出其他可以想象的顺序。 在这里，我们使weirdfib使用乘法（ * ）而不是加法（ + ）来组合术语，并且起始种子为[1,2,3]

from operator import mul

def weirdfib (n):
  return fibx(mul, [1,2,3], n)

print(weirdfib(0)) # 1
print(weirdfib(1)) # 2
print(weirdfib(2)) # 3
print(weirdfib(3)) # 6
print(weirdfib(4)) # 36
print(weirdfib(5)) # 648
print(weirdfib(6)) # 139968

Answer 2

您的问题描述告诉您原因：

序列将从三个1开始

但是，您的解决方案仅在n == 1或更低时返回1 ：

if n <= 1:
    return n

这意味着对于n == 2 （仍应返回1 ），您将改为返回fib3(2-1) + fib3(2-2) + fib3(2-3)或fib3(1) + fib3(0) + fib(-1) ，这要归功于上述测试，然后触底产生1 + 0 + -1 == 0 。

对于n == 3 ，您将返回fib3(2) + fib3(1) + fib3(0) ; 我们在上面得出的fib3(2)是fib3(2)是0 ，所以最终结果是0 + 1 + 0是您观察到的1 。

最后，第四个fib3数字（ n == 4 ）不返回3，而是fib3(3) + fib3(2) + fib3(1) == 1 + 0 + 1 == 2 。

将第一个测试返回1更改为n <= 3 ，以修复序列中的前三个值：

def fib3(n):
    if n <= 3:
        return 1
    else:
        return fib3(n-1) + fib3(n-2) + fib3(n-3)

现在，代码通过了给定的测试：

>>> def fib3(n):
...     if n <= 3:
...         return 1
...     else:
...         return fib3(n-1) + fib3(n-2) + fib3(n-3)
...
>>> print(fib3(3))
1
>>> print(fib3(4))
3
>>> print(fib3(7))
17
>>> print(fib3(9))
57

Answer 3

如果n <= 1 ，则情况要比仅return n更复杂。

考虑n = 4的情况：您的递归调用将是fib(3) ， fib(2)和fib(1) 。

最后一个立即返回1，这就是您想要的。 但是，这两个递归调用做一些奇怪的事情。 fib(2)递归为fib(1) ， fib(0)和fib(-1) ，其返回值基本上交出一个大的脂肪fib(3)递归为fib(2) （我们看到了是0）， fib(1) （有效且为1）和fib(0) （也是0）。

因此，您从一开始就获得1，而从fib(3)的递归fib(1)组件获得fib(1) 。 有你的2！

基本上，您要确保基本情况不能返回负数。 解决该问题（返回1或0），您应该会很好。 正如Martijn Pieters所提到的 ，您还可以使基本情况n <= 3 ，它应该达到相同的效果。

Answer 4

让我为最好的“ pythonic”答案做出贡献。

要点是避免递归函数调用以优化代码效率。 Python的思维方式将涉及以下紧凑代码，这是n个数字（包括种子数[1，1，1]）的斐波那契序列的迭代创建。

def fibonacci_sequence(n):
    x = [1, 1, 1]
    [x.append(x[-1] + x[-2] + x[-3]) for i in range(n - len(x))]
    return x

import time
n = int(raw_input("Enter the size of Fibonacci-3 sequence: "))
start_time = time.time()
print fibonacci_sequence(n)
print "The time to compute the Fibonacci-3 sequence is: %s" % (time.time() - start_time)