python - Python 2.7.3 中的内存错误

Question

我试图在 python 上运行这个程序，它模拟一个在太空中无意识的人，看看它是否会达到它的目标。但每次运行它时都会出现内存错误..--

init_posn=[0,0]
posn_final=[2,2]

obs = [[-1,1],[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1],[0,-1]]

# algo can be improved

def obs_det(posn_x,posn_y,obs):
    for e in obs:
        if e[0]==posn_x & e[1]==posn_y:
            return 1
    return 0

posn=[]
posn.append(init_posn)

def posn_progress(posn,posn_final,obs):
    i=0
    non=0
    while (non==0 | (posn[i][0]==posn_final[0] & posn[i][1]==posn_final[1])):
        l=posn[i][0]
        m=posn[i][1]
        if obs_det(l,m+1,obs) == 0:
            posn.append([l,m+1])
        elif obs_det(l+1,m,obs) == 0:
            posn.append([l+1,m])
        elif obs_det(l,m-1,obs) == 0:
            posn.append([l,m-1])
        elif obs_det(l-1,m,obs) == 0:
            posn.append([l-1,m])
        else:
            non=1
        i=i+1
    if non==1:
        return 0
    else:
        return posn

print posn_progress(posn,posn_final,obs)

Answer 1

这是一些示例代码；它基本上从起点进行洪水填充，直到到达终点。请注意，它会跟踪它已经去过的地方 ( seen)，因此它不会无休止地重新探索它们。

dir = [(dx,dy) for dx in (-1,0,1) for dy in (-1,0,1) if (dx,dy)!=(0,0)]

def backtrack(b, seen):
    if seen[b]==0:
        return [b]
    else:
        seek = seen[b]-1
        x,y = b
        for dx,dy in dir:
            p = (x+dx, y+dy)
            if p in seen and seen[p]==seek:
                return backtrack(p, seen) + [b]

def find_path(a, b, dist=0, here=None, seen=None):
    if here is None: here = set([a])
    if seen is None: seen = {a:0}

    next = set()
    for x,y in here:
        for dx,dy in dir:
            p = (x+dx, y+dy)
            if p not in seen:
                seen[p] = dist+1
                next.add(p)

    if b in seen:   # found it!
        return backtrack(b, seen)
    else:
        return find_path(a, b, dist+1, next, seen)

def main():
    print find_path((0,0), (2,2))

if __name__=="__main__":
    main()

Answer 2

因为这看起来像家庭作业，所以我将回答两个提示：

1. 您将如何编写单元测试来查看障碍物检测例程是否按预期工作？
2. 阅读有关逻辑和位运算符的信息。

Answer 3

我认为你的无意识存在是在兜圈子。

你可以教它避免回到它来自的地方。然后它不会循环，但可能无法找到路，即使存在一条路。

或者你可以让它更聪明，并告诉它如果它返回，下次它应该尝试不同的路线。