Question

我正在使用递归的Ackermanns函数。对于某些值，我的提示不会显示每个计算出的输出，因为Python会超过其递归限制，以至于在＃34; easy＆＃34;之前冻结提示。零件应该赶上它。

所以我想我可以在完全执行该函数后添加一个递归计数器和一个快速暂停。我得到了预期的输出，直到达到值（1,0）。之后我得到了TypeError: can only concatenate tuple (not "int") to tuple。

我的代码如下：

import time
import sys
sys.setrecursionlimit(3000)

def ackermann(i,j,rec):
    output = None
    if i==0:
        output = j+1
    elif j==0:
        output = ackermann(i-1,1,rec)
        rec=rec+1
    else:
        output = ackermann(i-1,ackermann(i,j-1,rec),rec)
        rec=rec+1
    return output,rec

rec=0
for i in range(5):
    for j in range(5):
        print("(",i,",",j,")= ",ackermann(i,j,rec))
        time.sleep(2)

请注意，删除rec（我的recurence计数器）的所有实例，程序运行正常。（您可以查看值i,j = 3）的所有输出

有人可以指出如何更正我的代码或提出一种不同的方法来查找Ackermann函数自己调用了多少次？

另外，我注意到设置5000的限制会使我的python内核崩溃得非常快。有上限吗？

我使用最新的Anaconda。

修改

我尝试使用列表作为参数来实现相同的功能，并使用以下数据[i,j,output,#recursion]

import time
import sys
sys.setrecursionlimit(3000)

def ackermann(*rec):
    rec=list(rec)
    print(rec) # see the data as they initialize the function
    if rec[0][0]==0:
        rec[0][1]=rec[0][1]+1
        rec[0][2] = rec[0][1]+1
    elif rec[0][1]==0:
        rec[0][0]=rec[0][0]-1
        rec[0][1]=1
        rec = ackermann()
        rec[0][3]=rec[0][3]+1
    else:
        rec[0][0]=rec[0][0]-1
        rec[0][1] = ackermann()
        rec = ackermann()
        rec[0][3]=rec[0][3]+1
    return rec

for i in range(5):
    for j in range(5):
        rec=[i,j,0,0]
        print(ackermann(rec))
        time.sleep(1)

但是这次我得到IndexError: list index out of range因为某些未知原因我的清单被清空

输出：

[[0, 0, 0, 0]]
[[0, 1, 2, 0]]
[[0, 1, 0, 0]]
[[0, 2, 3, 0]]
[[0, 2, 0, 0]]
[[0, 3, 4, 0]]
[[0, 3, 0, 0]]
[[0, 4, 5, 0]]
[[0, 4, 0, 0]]
[[0, 5, 6, 0]]
[[1, 0, 0, 0]]
[]

Answer 1

原始实现的问题在于 返回输出，rec 当输出和rec都是数字时，将很乐意创建一个元组，只要i = 0，这就是真的。但是一旦你得到i = 1，j = 0，该函数调用Ackerman（0,1，rec），它返回一个元组，然后它不能添加整数rec，因此错误消息。我相信我已经使用过这个想法，但几乎没有变化，除了试图通过并返回rec之外，我把它变成了全局（丑陋，我知道）。我也重新格式化了输出，所以我可以更好地阅读它。因此：

import time
import sys
sys.setrecursionlimit(3000)
def ackermann(i,j):
    global rec
    output = None
    if i==0:
        output = j+1
    elif j==0:
        output = ackermann(i-1,1)
        rec=rec+1
    else:
        output = ackermann(i-1,ackermann(i,j-1))
        rec=rec+1
    return output


for i in range(5):
    for j in range(5):
        rec = 0
        print
        print("ack("+str(i)+","+str(j)+") = "+str(ackermann(i,j)))
        print("rec = "+str(rec))
        print
        time.sleep(1)

和错误输出之前的输出是，

ack(0,0) = 1
rec = 0


ack(0,1) = 2
rec = 0


ack(0,2) = 3
rec = 0


ack(0,3) = 4
rec = 0


ack(0,4) = 5
rec = 0


ack(1,0) = 2
rec = 1


ack(1,1) = 3
rec = 2


ack(1,2) = 4
rec = 3


ack(1,3) = 5
rec = 4


ack(1,4) = 6
rec = 5


ack(2,0) = 3
rec = 3


ack(2,1) = 5
rec = 8


ack(2,2) = 7
rec = 15


ack(2,3) = 9
rec = 24


ack(2,4) = 11
rec = 35


ack(3,0) = 5
rec = 9


ack(3,1) = 13
rec = 58


ack(3,2) = 29
rec = 283


ack(3,3) = 61
rec = 1244


ack(3,4) = 125
rec = 5213


ack(4,0) = 13
rec = 59

在我看来，只有一两个其他值（它会扼杀4,2我相信，无论如何，所以你需要先获得5,0）你可能希望以这种方式走出去，不管你修补多少。

我有点担心rec似乎超过递归限制，但我认为Python必须以某种方式解释，以便它比人们想象的更深，或者我不完全理解sys.recursionlimit （我看了几次rec，至少我跟着你的计算它的导致;另外，作为一个完整性检查，我改变了递增它的顺序和函数调用并得到了相同的结果）。

编辑：我添加了另一个参数来跟踪任何特定呼叫的重复程度。结果通常小于（并且最多只有一个）“rec”。 rec表示（实际上小于1）调用函数进行特定计算的次数，但并非所有这些都需要同时在Python解释器堆栈上。

修订代码：

import time
import sys
sys.setrecursionlimit(3000)
def ackermann(i,j,d):
    global rec
    global maxDepth
    if ( d  > maxDepth ) : maxDepth = d
    output = None
    if i==0:
        output = j+1
    elif j==0:
        rec=rec+1
        output = ackermann(i-1,1, d+1)
    else:
        rec=rec+1
        output = ackermann(i-1,ackermann(i,j-1, d+1),d+1)
    return output


for i in range(5):
    for j in range(5):
        rec = 0
        maxDepth=0
        print
        print("ack("+str(i)+","+str(j)+") = "+str(ackermann(i,j,1)))
        print("rec = "+str(rec))
        print("maxDepth = "+str(maxDepth))
        print
        time.sleep(1)

修改后的输出（放弃之前）

ack(0,0) = 1
rec = 0
maxDepth = 1


ack(0,1) = 2
rec = 0
maxDepth = 1


ack(0,2) = 3
rec = 0
maxDepth = 1


ack(0,3) = 4
rec = 0
maxDepth = 1


ack(0,4) = 5
rec = 0
maxDepth = 1


ack(1,0) = 2
rec = 1
maxDepth = 2


ack(1,1) = 3
rec = 2
maxDepth = 3


ack(1,2) = 4
rec = 3
maxDepth = 4


ack(1,3) = 5
rec = 4
maxDepth = 5


ack(1,4) = 6
rec = 5
maxDepth = 6


ack(2,0) = 3
rec = 3
maxDepth = 4


ack(2,1) = 5
rec = 8
maxDepth = 6


ack(2,2) = 7
rec = 15
maxDepth = 8


ack(2,3) = 9
rec = 24
maxDepth = 10


ack(2,4) = 11
rec = 35
maxDepth = 12


ack(3,0) = 5
rec = 9
maxDepth = 7


ack(3,1) = 13
rec = 58
maxDepth = 15


ack(3,2) = 29
rec = 283
maxDepth = 31


ack(3,3) = 61
rec = 1244
maxDepth = 63


ack(3,4) = 125
rec = 5213
maxDepth = 127


ack(4,0) = 13
rec = 59
maxDepth = 16

Answer 2

在你编辑的代码版本中，你在def中使用了一个* arg作为ackerman并明确地将它作为一个列表，你得到11个输出列表，每个列表包含一个四元素列表，直到第12次递归你得到一个空列表。那么，根据ackermann约束，前11个列表是否包含预期的元素？另外，在第十二次递归中，你说列表已经被清空了。＆＃34;我不知道是否有分析目的，如果说它可能是有意义的，而不是首先填补它。也就是说，并没有把它清空的东西，而是在第12次通过时没有按预期填充它。

如何计算Python中函数的递归调用？

2 个答案: