テキスト比較

2 つのテキストファイルの違いを見つける

ライブエディター

未変更行を折りたたむ

折り返しなし

レイアウト

比較精度

シンタックスハイライト

Diffchecker Desktop Diffcheckerを実行する最も安全な方法。Diffchecker Desktopアプリを入手：あなたの差分はコンピューターから出ることはありません！Desktopを入手

MCS 275 2022 worksheet 7 question 3

作成日 4 年前差分は期限切れになりません

9 削除

行
合計
削除

文字
合計
削除

この機能を引き続き使用するには、アップグレードしてください Diffchecker Pro 価格を見る

34 行

25 追加

行
合計
追加

文字
合計
追加

この機能を引き続き使用するには、アップグレードしてください Diffchecker Pro 価格を見る

39 行

def solvemaze(M,path=None):

def solvemaze_history(M,path_list=None, solved=False):

"""

Find a solution to maze `M`

Functions similarly to `solvemaze`, but returns a list of all paths

using a depth-first recursive

considered throughout solving process. Uses additional arg `solved`

search.

to track whether solution has been found.

"""

print("Called with path={}".format(path))

if path_list==None:

if path==None:

# no path specified, so start

# at M.start

path = [M.start]

path_list = [[M.start]] # Use a list of lists for path_list - one list for each path.

else:

print("Called with path={}".format(path_list[-1]))

path = path_list[-1]

if path[-1]==M.goal:

# We've found a solution

print("SOLVED!")

return path

return path_list, True # Set the "solved" variable to True

# next steps to consider

# (may include retracing our steps)

steps = M.free_neighbors(*path[-1])

for s in steps:

if len(path)>=2 and s == path[-2]:

print("Not considering {}, as it would retrace our steps".format(s))

continue

# Consider whether next step `s` leads to a solution

print("Considering next step {}".format(s))

soln = solvemaze(M,path + [s])

next_path = path + [s]

if soln != None:

path_list.append(next_path)

soln, solved = solvemaze_history(M,path_list)

if solved:

# Some recursive call yielded a solution!

print("Hooray, considering {} worked!".format(s))

return soln

return soln, True # # Set the "solved" variable to True

# if we reach this line, step `s` only led to dead ends

# if we reach this line, then no continuation of `path`

# leads to a solution, only dead ends.

# Still need to return path_list so we can visualize it later

print("Path {} leads only to dead ends".format(path))

return None

return path_list, False # Keep the "solved" variable as False.

保存された差分

原文

ファイルを開く

def solvemaze(M,path=None):
    """
    Find a solution to maze `M`
    using a depth-first recursive
    search.
    """
    print("Called with path={}".format(path))
    if path==None:
        # no path specified, so start
        # at M.start
        path = [M.start]
    if path[-1]==M.goal:
        # We've found a solution
        print("SOLVED!")
        return path
    # next steps to consider
    # (may include retracing our steps)
    steps = M.free_neighbors(*path[-1])
    for s in steps:
        if len(path)>=2 and s == path[-2]:
            print("Not considering {}, as it would retrace our steps".format(s))
            continue
        # Consider whether next step `s` leads to a solution
        print("Considering next step {}".format(s))
        soln = solvemaze(M,path + [s])
        if soln != None:
            # Some recursive call yielded a solution!
            print("Hooray, considering {} worked!".format(s))
            return soln
        # if we reach this line, step `s` only led to dead ends
    # if we reach this line, then no continuation of `path`
    # leads to a solution, only dead ends.
    print("Path {} leads only to dead ends".format(path))
    return None

変更されたテキスト

ファイルを開く

def solvemaze_history(M,path_list=None, solved=False):
    """
    Functions similarly to `solvemaze`, but returns a list of all paths
    considered throughout solving process. Uses additional arg `solved`
    to track whether solution has been found.
    """
    if path_list==None:
        # no path specified, so start
        # at M.start
        path_list = [[M.start]] # Use a list of lists for path_list - one list for each path.
    else:
        print("Called with path={}".format(path_list[-1]))
    path = path_list[-1]
    if path[-1]==M.goal:
        # We've found a solution
        print("SOLVED!")
        return path_list, True # Set the "solved" variable to True
    # next steps to consider
    # (may include retracing our steps)
    steps = M.free_neighbors(*path[-1])
    for s in steps:
        if len(path)>=2 and s == path[-2]:
            print("Not considering {}, as it would retrace our steps".format(s))
            continue
        # Consider whether next step `s` leads to a solution
        print("Considering next step {}".format(s))
        next_path = path + [s]
        path_list.append(next_path)
        soln, solved = solvemaze_history(M,path_list)
        if solved:
            # Some recursive call yielded a solution!
            print("Hooray, considering {} worked!".format(s))
            return soln, True # # Set the "solved" variable to True
        # if we reach this line, step `s` only led to dead ends
    # if we reach this line, then no continuation of `path`
    # leads to a solution, only dead ends.
    # Still need to return path_list so we can visualize it later
    print("Path {} leads only to dead ends".format(path))
    return path_list, False # Keep the "solved" variable as False.