텍스트 비교

두 텍스트 파일의 차이점을 찾아보세요

실시간 편집

변경 없는 행 숨기기

줄바꿈 비활성화

레이아웃

비교 단위

구문 강조

Diffchecker Desktop 가장 안전하게 Diffchecker를 사용하는 방법. 데스크톱 앱을 사용하면 비교 데이터가 외부로 전송되지 않습니다!데스크톱 앱 받기

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.