Question

我的代码如下。

我首先尝试为每个案例编码，所以给定n = 4，我的代码看起来像这样：

a = overlay_frac(0,blank_bb,scale(1/4,rune))
b = overlay_frac(1/4,blank_bb,scale(1/2,rune))
c = overlay_frac(1/2,blank_bb,scale(3/4,rune))
d = overlay_frac(3/4,blank_bb,scale(1,rune))
show (overlay(a,(overlay(b,(overlay(c,d))))))

我的理解是递归模式是：

a = overlay_frac((1/n)-(1/n),blank_bb,scale(1/n,rune))
b = overlay_frac((2/n)-(1/n),blank_bb,scale(2/n,rune))
c = overlay_frac((3/n)-(1/n),blank_bb,scale(3/n,rune))
d = overlay_frac((4/n)-(1/n),blank_bb,sale(4/n,rune))

因此，我想出的递归模式是：

def tree(n,rune):
    if n==1:
        return rune
    else:
        for i in range(n+1):
            return overlay(overlay_frac(1-(1/n),blank_bb,scale(i/n,rune)),tree(n-1,rune))

当我对此进行硬编码时，一切都很好，但我怀疑我没有正确地进行递归。我哪里出错？

Answer 1

您实际上是在尝试在递归调用中进行迭代。您可以使用内部函数来记忆您的状态，而不是使用循环。您定义的系数实际上随n和i一起更改，但对于给定的n，它仅更改为i。然后，使用内部函数记忆所需的状态为i，这与循环遍历i的状态相同。

您仍然可以通过这样做来实现目标

def f(i, n): 
  return overlay_frac((i/n)-(1/n),blank_bb,scale(i/n,rune))

# for each iteration, you check if i is equal to n
# if yes, return the result (base case)
# otherwise, you apply next coefficient to the previous result
# you start with i = 0 and increase by one every iteration until i reach to n (base case)
# notice how similar this recursive call looks like a loop
# the only difference is the status are updated within the function call itself
# therefore you will not have the problem of earlier return 
def recursion(n):
  def iteration(i, out):
    if i == n:
      return out
    else:
      return iteration(i+1, overlay(f(n-1, n), out))
  return iteration(0, f(n, n))

此处，n被假定为您想要应用的叠加时间。 n = 0时，最后一个系数f(n, n)上没有应用任何函数。在n = 1时，输出将在系数i = n - 1和系数i = n上叠加一次。

这样可以避免循环中的早期返回。

实际上，您可以通过向外部函数添加其他参数来省略内部函数。然后，您需要指定默认的初始i。内部功能在这里并不是必需的。关键是使用函数参数来记忆状态（在这种情况下为变量i）。

def f(i, n): 
  return overlay_frac((i/n)-(1/n),blank_bb,scale(i/n,rune))

def recursion(n, i=0):
    if i == n:
      return f(n, n)
    else:
      return overlay(f(n-1, n), recursion(n, i+1))

Answer 2

您的前两个代码块并不对应相同的操作。这相当于你的第一个块（在Python 3中）。

def overlayer(n, rune):
    def layer(k):
        # Scale decreases linearly with k
        return overlay_frac((1 - (k+1)/n), blank_bb, scale(1-k/n, rune))
    result = layer(0)
    for i in range(1, n):
        # Overlay on top of previous layers
        result = overlay(layer(i), result)
    return result

show(overlayer(4, rune))

Answer 3

让我们再看看你的方程式：

a = overlay_frac(0,blank_bb,scale(1/4,rune))
b = overlay_frac(1/4,blank_bb,scale(1/2,rune))
c = overlay_frac(1/2,blank_bb,scale(3/4,rune))
d = overlay_frac(3/4,blank_bb,scale(1,rune))
show (overlay(a,(overlay(b,(overlay(c,d))))))

你写的“递归”不是递归公式。如果你将递归的公式与你给我们的公式进行比较，你可以推断出n=4没有意义。对于递归模式，您需要将内部变量描述为仅具有不同参数的同一表达式的表现形式。也就是说，你应该替换：

f_n = overlay_frac((1/4)*(n-1),blank_bb,sale(n/4,rune))

这样f_1=a, f_2=b等...

然后，您想要计算的递归公式转换为：

show (overlay(f_1,(overlay(f_2,(overlay(f_3,f_4))))))

您可以在代码中将函数f_n写为f(n)（也可能是其他参数）然后执行

def recurse(n):
    if n == 4:
        return f(4)
    else:
        return overlay(f(n),recurse(n+1))

然后致电：

show( recurse (1))

你需要断言n<5和整数，否则你将最终进入无限循环。可能仍然存在一些错误，但它应该是这样的。一旦你真的这样写了它，它（也许）反正做一个递归是没有意义的。如果您只想为n_max=4执行此操作，那就是。只需将a,b,c,d替换为f_1,f_2,f_3,f_4

，即可在一行中调用该函数

如何找到递归条件？

3 个答案: