Question

我想对连续分数使用递归，就像这样。

用户将输入n值，如果n为3，则它将像这样：

2 + 1 /（1 +1 /（2 + 2 /（3 + 3/4）））

方程式中的前2 + 1 /是固定的，现在我们必须计算它后面的数字。这是我几天来一直在挠头的部分。有人告诉我可以使用递归来计算该部分，但是我一直在尝试学习如何使用它，但是我的循环永远存在或存在recursionError

n = int(input("Enter n value: "))
result = 0
fract = 0

def frac(j):
    global fract
    for i in range(j):
        fract = (j + j)/ frac(j)
    return fract

def calc_e():
    e = 2 + 1/ frac(n) / n + 1
    return e

print(calc_e())

#formula = 2 + 1 / (1 + 1 / (2 + 2 / (3 + 3 / (4 + 4 / (...)))))

TLDR：我不知道如何计算2 +1 /

之后的部分

Answer 1

您可以使用简单的递归：

#2 + 1/ (1 + 1 / (2 + 2/ (3 + 3 / 4)))
def get_equation(_to_val, string_rep = False):
   if string_rep:
     def calculate(start, end):
       return '{}+{}/({})'.format(start, start, calculate(start+1, end) if start < end else end+1)
     return '2+1/({})'.format(calculate(1, _to_val))
   def calculate(start, end):
      return start+start/(calculate(start+1, end) if start < end else end+1)
   return calculate(1, _to_val)


print(get_equation(3))
print(get_equation(3, True))

输出：

1.3947368421052633
2+1/(1+1/(2+2/(3+3/(4))))

Answer 2

您的frac例程中存在一些基本问题

def frac(j):
    global fract
    for i in range(j):
        fract = (j + j)/ frac(j)
    return fract

您尚未决定如何传递结果：您一直在更新全局fract，但随后返回其值。这些只是其中之一。
类似地，您将通过{em>和递归的{em> 遍历连续分数。您应该只使用其中之一。
您的递归没有基本情况：没有什么可告诉算法它已经“触底”。每次执行计算步骤时，都重复for；没有不重复发生的逻辑路径。这是获得无限递归的主要原因。如果这些是新概念，请阅读递归教程。至少会尽我们所能解释。
您的代数是错误的：frac是错误的运算顺序，仅给您(j + j)/ frac(j)。您应该有类似2*j / frac(j)的内容。

是否有足够的提示可以帮助您进行更有用的编码实践？您可能还需要帮助调试。一些精选的j + j/frac(j+1)语句通常会向您显示正在发生的事情。请访问这个可爱的debug博客以获取帮助。

Answer 3

无需使用global变量；我也看不到需要for循环的地方。正如先前的答案所指出的那样，您有一些代数错误。

您应该向frac添加一个停止条件参数，以阻止其无限递归。如果被击中，则返回值j：

# max number of terms n
def frac(j, n):
    if j >= n: return n
    return j + j / frac(j+1, n)

# remember to pass 1.0 instead of 1, or cast to float in frac
# to avoid integer division which will truncate all fractions
def calc_e(n=100):
    return 2 + 1 / frac(1.0, n)

这将返回：

n    calc_e(n)
----------------------
2    2.666666666666667
4    2.716981132075472
8    2.718281657666404
16   2.718281828459045
32   2.718281828459046
64   2.718281828459046
128  2.718281828459046
256  2.718281828459046
512  2.718281828459046

由于堆栈溢出，无法进行更多的递归操作。

在数学数字序列上使用递归？

3 个答案: