def findPath(self):
s = Stack() #stack to save the path
s.push(self._startCell)
self._markPath(self._startCell.row, self._startCell.col)
while True:
#inside the loop where neighbor cell is checked for valid move
#same time, checked if we get the exit
if s.isEmpty():
return False
current_cell = s.peek()
row = current_cell.row
col = current_cell.col
if not self._exitFound(row, col):
for r in [row - 1, row, row + 1]:
if not (current_cell.row == s.peek().row and \
current_cell.col == s.peek().col):
break
for c in [col - 1, col, col + 1]:
if ((r == row) ^ (c == col)):
if self._validMove(r, c):
self._markPath(r, c)
s.push(_CellPosition(r, c))
break
if current_cell.row == s.peek().row and\
current_cell.col == s.peek().col:
not_in_path = s.pop()
self._markTried(not_in_path.row, not_in_path.col)
else:
return True
def findPath(self):
path = Stack()
path.push(self._startCell)
self._mazeCells[self._startCell.row, self._startCell.col] = \
self.PATH_TOKEN
while not self._exitFound(path.peek().row, path.peek().col):
curr = path.peek()
if self._validMove(curr.row - 1, curr.col):
path.push(_CellPosition(curr.row - 1, curr.col))
self._markPath(curr.row - 1, curr.col)
elif self._validMove(curr.row, curr.col - 1):
path.push(_CellPosition(curr.row, curr.col - 1))
self._markPath(curr.row, curr.col - 1)
elif self._validMove(curr.row + 1, curr.col):
path.push(_CellPosition(curr.row + 1, curr.col))
self._markPath(curr.row + 1, curr.col)
elif self._validMove(curr.row, curr.col + 1):
path.push(_CellPosition(curr.row, curr.col + 1))
self._markPath(curr.row, curr.col + 1)
else:
path.pop()
self._markTried(curr.row, curr.col)
if len(path) == 0:
return False
return True
def findPath(self):
path_stack = Stack()
new = self._startCell
path_stack.push(new)
while len(path_stack) != 0:
new.row = path_stack.peek().row
new.col = path_stack.peek().col
self._markPath(new.row, new.col)
flag_valid = False
for i, j in [(-1, 0), (0, 1), (1, 0), (0, -1)]:
if self._validMove(path_stack.peek().row + i,
path_stack.peek().col + j):
new.row = new.row + i
new.col = new.col + j
path_stack.push(_CellPosition(new.row, new.col))
self._markPath(new.row, new.col)
flag_valid = True
break
if flag_valid:
if self._exitFound(new.row, new.col):
self._markPath(new.row, new.col)
return True
continue
cell = path_stack.pop()
self._markTried(cell.row, cell.col)
return False
def findPath( self ):
path_stack = Stack()
cur_cell = self._startCell
path_stack.push(cur_cell)
self._markPath( cur_cell.row, cur_cell.col )
while len( path_stack ) != 0:
flag_valid = 0
for (v, h) in [(1, 0), (-1, 0), (0, -1), (0 ,1)]:
cur_row = cur_cell.row + v
cur_col = cur_cell.col + h
if self._validMove( cur_row, cur_col ):
path_stack.push( _CellPosition(cur_row, cur_col) )
self._markPath( cur_row, cur_col )
#print "( " + str(cur_row) + ", " + str(cur_col) + " ) is valid Path Point"
flag_valid = 1
break
if flag_valid == 0:
pop_cell = path_stack.pop()
self._markTried( pop_cell.row, pop_cell.col )
#print "( " + str(pop_cell.row) + ", " + str(pop_cell.col) + " ) is Invalid Path Point"
if len(path_stack) == 0:
return False
cur_cell = path_stack.peek()
#print "( " + str(cur_cell.row) + ", " + str(cur_cell.col) + " ) is on the top."
if self._exitFound( cur_cell.row, cur_cell.col ):
#print len(path_stack)
return True
def find_path(self):
stack = Stack()
current = self.startCell
current.path.append(current)
current.parent = current
if current == self.exitCell:
return True
home_cords_nei = self.check_neighbors(current.row, current.col)
for cell in home_cords_nei:
if cell == self.exitCell:
return True
cell.path.append(current)
stack.push(cell)
self.mark_tried(current.row, current.col)
while not stack.isEmpty():
parent = current
current = stack.peek()
current.parent = parent
current.path += parent.path
current.path.append(current)
self.mark_tried(current.row, current.col)
if self.exit_found(current.row, current.col):
self.exit = current
return True
stack.pop()
for cell in self.check_neighbors(current.row, current.col):
stack.push(cell)
return False
def findPath(self):
"""
finds path in a Maze and Returns True
if no path it will return None
"""
maze_stack = Stack()
maze_stack.push(self._startCell)
current_cell = self._startCell
self._markPath(self._startCell.row, self._startCell.col)
while not maze_stack.isEmpty():
possible_moves = [(-1, 0), (0, 1), (1, 0), (0, -1)]
current_cell.row = maze_stack.peek().row
current_cell.col = maze_stack.peek().col
self._markPath(current_cell.row, current_cell.col)
moved = False
for i, j in possible_moves:
if self._validMove(current_cell.row + i, current_cell.col + j):
current_cell.row = current_cell.row + i
current_cell.col = current_cell.col + j
maze_stack.push(
_CellPosition(current_cell.row, current_cell.col))
moved = True
break
if moved:
if self._exitFound(current_cell.row, current_cell.col):
self._markPath(current_cell.row, current_cell.col)
return True
continue
visited_cell = maze_stack.pop()
self._markTried(visited_cell.row, visited_cell.col)
def find_path(self):
"""
Attempts to solve the maze by finding a path from the starting cell
to the exit. Returns True if a path is found and False otherwise.
"""
stack_of_cells = Stack()
stack_of_cells.push((self._start_cell.row, self._start_cell.col))
self._mark_path(self._start_cell.row, self._start_cell.col)
while not stack_of_cells.is_empty():
current_cell = stack_of_cells.peek()
valid_neighbor = False
for direction in directions:
if self._valid_move(current_cell[0] + direction[0],
current_cell[1] + direction[1]):
stack_of_cells.push((current_cell[0] + direction[0],
current_cell[1] + direction[1]))
valid_neighbor = True
self._mark_path(current_cell[0] + direction[0],
current_cell[1] + direction[1])
if self._exit_found(current_cell[0] + direction[0],
current_cell[1] + direction[1]):
return True
break #we don't need 2 valid neighbor at the same time
if not valid_neighbor:
self._mark_tried(current_cell[0], current_cell[1])
stack_of_cells.pop()
return False
def __delitem__(self, target):
assert target is not None, "Invalid map key."
keyFound = False
nodeTrack = Stack()
node = self._root
while node is not None:
nodeTrack.push(node)
if node.hasKey(target):
keyFound = True
break
else:
node = node.getBranch(target)
if not keyFound: # If target key not found...
raise KeyError(target)
# If the target node is not a leaf node, swap item with its in-order
# successor (always leaf), and then go to the new location of item
# to delete.
if not nodeTrack.peek().isLeaf():
transNode = nodeTrack.peek()
if transNode.key1 == target:
node = transNode.middle
else:
node = transNode.right
nodeTrack.push(node)
while not node.isLeaf():
node = node.left
nodeTrack.push(node)
# <node> is anow the leaf node containing the in-order successor
# key of <target>.
if transNode.key1 == target:
transNode.key1, node.key1 = node.key1, transNode.key1
transNode.value1, node.value1 = node.value1, transNode.value1
else:
transNode.key2, node.key1 = node.key1, transNode.key2
transNode.value2, node.value1 = node.value1, transNode.value2
leafNode = nodeTrack.pop()
if leafNode.isFull():
self._t23DegFull(leafNode, target)
else:
leafNode.key1 = None
leafNode.value1 = None
self._t23FixNode(nodeTrack, leafNode)
self._size -= 1
class ExtoPostfix:
"""
Receive an infix expression and turn it into a postfix expression.
This is a helper module of postfixCal.py.
"""
def __init__(self):
self._isp = {'#':0, '(':1, '*':5, '/':5, '+':3, '-':3, ')':6} #in stack priority
self._icp = {'#':0, '(':6, '*':4, '/':4, '+':2, '-':2, ')':1} #in coming priority
self._postfix = [] #the list used to save the final postfix expression.
self._oprtStack = Stack() #the stack used to change the order of operators.
def __str__(self):
self._postfix = [elem for elem in self._postfix if elem != ')' and elem != '(']
return ','.join(self._postfix)
def _getPostfix(self,expr):
"""
Algorithm:
1)initialize the _oprtStack by pushing '#' into it.
2)read in the first element of the infix expr, and assign it to variable ch.
3)repeat the following steps until ch = '#', meanwhile, the top element of the _oprtStack is also '#':
a)if ch is operand, append it to the _postfix, and read the next ch;
b)if ch is operator, compare the priority(icp) of ch and the priority(isp) of the top element(op) in _oprtStack:
if icp(ch) > isp(op), push ch onto _oprtStack, and read another ch
if icp(ch) < isp(op), pop the top element in _oprtStack, and append it to _postfix
if icp(ch) == isp(op), pop the top element in _oprtStack,if op is '(', read another ch.
"""
expr = expr.split()
self._oprtStack.push('#')
ch = expr.pop(0)
while self._oprtStack.isEmpty()==False and ch != '#':
if ch.isdigit():
self._postfix.append(ch)
ch = expr.pop(0)
else:
ch1 = self._oprtStack.peek()
if self._isp[ch1] < self._icp[ch]:
self._oprtStack.push(ch)
ch = expr.pop(0)
elif self._isp[ch1] > self._icp[ch]:
out = self._oprtStack.pop()
self._postfix.append(out)
else:
out = self._oprtStack.pop()
if out == '(':
ch = expr.pop(0)
for i in range(len(self._oprtStack)-1):
ch1 = self._oprtStack.pop()
self._postfix.append(ch1)
def backExpr(self,expr):
self._getPostfix(expr)
return self._postfix
def findPath( self ):
stack = Stack()
self._markPath(self._startCell.row, self._startCell.col)
stack.push(self._startCell)
while not stack.isEmpty():
# debug
stack.show()
cur = _CellPosition(0, 0)
cur.row = stack.peek().row
cur.col = stack.peek().col
print "current:"
print (cur.row, cur.col)
if cur.row == self._exitCell.row and \
cur.col == self._exitCell.col:
print "findPath ok"
return 1
if self.haveUp(cur.row, cur.col):
cur.row = cur.row - 1
stack.push(cur)
self._markPath(cur.row, cur.col)
continue
if self.haveRight(cur.row, cur.col):
cur.col = cur.col + 1
stack.push(cur)
self._markPath(cur.row, cur.col)
continue
if self.haveDown(cur.row, cur.col):
cur.row = cur.row + 1
stack.push(cur)
self._markPath(cur.row, cur.col)
continue
if self.haveLeft(cur.row, cur.col):
cur.col = cur.col - 1
stack.push(cur)
self._markPath(cur.row, cur.col)
continue
print "aaaaaaaaaaaaa"
self._markTried(cur.row, cur.col)
stack.pop()
stack.show()
print "findPath fail"
return 0
def findPath(self):
_pathStack = Stack()
assert self._startPos is not None, "starting position is not defined"
_pathStack.push(self._startPos)
_currentCellRow = _pathStack.peek().row
_currentCellCol = _pathStack.peek().col
while ([_currentCellRow, _currentCellCol] !=
[self._endPos.row, self._endPos.col]):
print("here")
_nextPath = False
_check = False
for i, j in itertools.product(range(-1, 2, 1), repeat=2):
if (abs(i - j) == 1):
_nextPath = self._validMove(_currentCellRow + i,
_currentCellCol + j)
if (_nextPath):
_check = True
print(_currentCellRow + i, _currentCellCol + j, "\n")
self._maze[_currentCellRow + i,
_currentCellCol + j] = self.MAZE_PATH_TOKEN
_pathStack.push(
CellPosition(_currentCellRow + i,
_currentCellCol + j))
break
if (not _check):
removedPath = _pathStack.pop()
self._maze[removedPath.row,
removedPath.col] = self.MAZE_TRIED_TOKEN
if (_pathStack is None):
return False
_currentCellRow = _pathStack.peek().row
_currentCellCol = _pathStack.peek().col
return True
def find_path(self):
"""
Attempts to solve the maze by finding a path from the starting cell
to the exit. Returns True if a path is found and False otherwise.
"""
empty = self.empty_path()
self.reset()
mid_pos = self._start_cell
path = Stack()
self._mark_path(mid_pos.row, mid_pos.col)
path.push(mid_pos)
while mid_pos != self._exit_cell and empty:
if _CellPosition(mid_pos.row - 1, mid_pos.col) in empty:
mid_pos = _CellPosition(mid_pos.row - 1, mid_pos.col)
empty.remove(mid_pos)
self._mark_path(mid_pos.row, mid_pos.col)
path.push(mid_pos)
continue
elif _CellPosition(mid_pos.row, mid_pos.col + 1) in empty:
mid_pos = _CellPosition(mid_pos.row, mid_pos.col + 1)
empty.remove(mid_pos)
self._mark_path(mid_pos.row, mid_pos.col)
path.push(mid_pos)
elif _CellPosition(mid_pos.row + 1, mid_pos.col) in empty:
mid_pos = _CellPosition(mid_pos.row + 1, mid_pos.col)
empty.remove(mid_pos)
self._mark_path(mid_pos.row, mid_pos.col)
path.push(mid_pos)
elif _CellPosition(mid_pos.row, mid_pos.col - 1) in empty:
mid_pos = _CellPosition(mid_pos.row, mid_pos.col - 1)
empty.remove(mid_pos)
self._mark_path(mid_pos.row, mid_pos.col)
path.push(mid_pos)
else:
self._mark_tried(mid_pos.row, mid_pos.col)
path.pop()
try:
mid_pos = path.peek()
except AssertionError:
return False
return True
def findPath(self):
path_stack = Stack()
path_stack.push(self._startCell)
# print(path_stack.peek().row, path_stack.peek().col)
while len(path_stack) > 0:
pos_row = path_stack.peek().row
pos_col = path_stack.peek().col
if self._validMove(pos_row - 1, pos_col):
self._mazeCells[pos_row, pos_col] = self.PATH_TOKEN
path_stack.push(_CellPosition(pos_row - 1, pos_col))
if self._exitFound(pos_row - 1, pos_col):
self._mazeCells[pos_row - 1, pos_col] = self.PATH_TOKEN
return True
elif self._validMove(pos_row + 1, pos_col):
self._mazeCells[pos_row, pos_col] = self.PATH_TOKEN
path_stack.push(_CellPosition(pos_row + 1, pos_col))
if self._exitFound(pos_row + 1, pos_col):
self._mazeCells[pos_row + 1, pos_col] = self.PATH_TOKEN
return True
elif self._validMove(pos_row, pos_col - 1):
self._mazeCells[pos_row, pos_col] = self.PATH_TOKEN
path_stack.push(_CellPosition(pos_row, pos_col - 1))
if self._exitFound(pos_row, pos_col - 1):
self._mazeCells[pos_row, pos_col - 1] = self.PATH_TOKEN
return True
elif self._validMove(pos_row, pos_col + 1):
self._mazeCells[pos_row, pos_col] = self.PATH_TOKEN
path_stack.push(_CellPosition(pos_row, pos_col + 1))
if self._exitFound(pos_row, pos_col + 1):
self._mazeCells[pos_row, pos_col + 1] = self.PATH_TOKEN
return True
else:
self._mazeCells[pos_row, pos_col] = self.TRIED_TOKEN
path_stack.pop()
return False
def find_path(self):
if not self.maze_cells[self.exit_cell.row, self.exit_cell.col] is None:
return False
tmp = Stack()
i, j = self.start_cell.row, self.start_cell.col
dead_ends = [self.CELL_PATH, self.CELL_TRIED, self.CELL_WALL]
directions = [(1, 0), (0, 1), (-1, 0), (0, -1)]
tmp.push([i, j])
self.maze_cells[i, j] = self.CELL_PATH
while True:
for direction in directions:
try:
i1, j1 = i + direction[0], j + direction[1]
t = self.maze_cells[i1, j1]
except IndexError:
continue
while self.maze_cells[i1, j1] \
not in dead_ends:
i += direction[0]
j += direction[1]
tmp.push([i, j])
self.maze_cells[i, j] = self.CELL_PATH
if i == self.exit_cell.row and j == self.exit_cell.col:
return True
if i == self.start_cell.row and j == self.start_cell.col:
return False
if self.check_cell(i, j) is None:
while True:
coor = tmp.pop()
if tmp.isEmpty():
return False
self.maze_cells[coor[0], coor[1]] = self.CELL_TRIED
coor = tmp.peek()
tmpcoor = self.check_cell(coor[0], coor[1])
if tmpcoor:
i, j = coor[0], coor[1]
break
if i == self.start_cell.row and j == self.start_cell.col:
return False
if i == self.exit_cell.row and j == self.exit_cell.col:
return True
def find_path(self):
"""
Attempts to solve the maze by finding a path from the starting cell
to the exit. Returns True if a path is found and False otherwise.
"""
maze_path = Stack()
first_position = self._start_cell
curr_row = first_position.row
curr_col = first_position.col
maze_path.push(_CellPosition(curr_row, curr_col))
self._mark_path(curr_row, curr_col)
while not self._exit_found(curr_row, curr_col):
for direction in [(-1, 0), (0, 1), (1, 0), (0, -1)]:
new_row = curr_row + direction[0]
new_col = curr_col + direction[1]
if self._valid_move(new_row, new_col):
curr_row = new_row
curr_col = new_col
maze_path.push(_CellPosition(curr_row, curr_col))
self._mark_path(curr_row, curr_col)
break
else:
continue
else:
self._mark_tried(curr_row, curr_col)
maze_path.pop()
if maze_path.is_empty():
return False
previous_cell = maze_path.peek()
curr_row = previous_cell.row
curr_col = previous_cell.col
return True
class Maze:
# Define constants to represent contents of the maze cells.
MAZE_WALL = "%" # *
PATH_TOKEN = "." # x
TRIED_TOKEN = "-" # o
# Creates a maze object with all cells marked as open.
def __init__(self, numRows, numCols):
self._mazeCells = Array2D(numRows, numCols)
self._startCell = None
self._exitCell = None
self._path = Stack()
self._path_found = False
# Returns the number of rows in the maze.
def numRows(self):
return self._mazeCells.numRows()
# Returns the number of columns in the maze.
def numCols(self):
return self._mazeCells.numCols()
# Fills the indicated cell with a "wall" marker.
def setWall(self, row, col):
assert row >= 0 and row < self.numRows() and col >= 0 and col < self.numCols(), "Cell index out of range."
self._mazeCells.__setitem__((row, col), self.MAZE_WALL)
# Sets the starting cell position.
def setStart(self, row, col):
assert row >= 0 and row < self.numRows() and col >= 0 and col < self.numCols(), "Cell index out of range."
self._startCell = _CellPosition(row, col)
# Sets the exit cell position.
def setExit(self, row, col):
assert row >= 0 and row < self.numRows() and col >= 0 and col < self.numCols(), "Cell index out of range."
self._exitCell = _CellPosition(row, col)
# Attempts to solve the maze by finding a path from the starting cell
# to the exit. Returns True if a path is found and False otherwise.
def findPath(self):
start = (self._startCell.row, self._startCell.col)
end = (self._exitCell.row, self._exitCell.col)
# If start is the same as end, then there's an error
if start == end:
return False
self._path.push(start)
self.make_a_move()
return self._path_found
def make_a_move(self):
# Keep recursion going until stack is empty from not
# finding a path
if self._path._size > 0:
cur_row, cur_col = self._path.peek()
# If the current cell is also the exit cell
# Break out of the recursion and return True!
if self._exitFound(cur_row, cur_col):
self._markPath(cur_row, cur_col)
self._path_found = True
return
# Checks to see if any of the surrounding cells are
# valid to move into- up, right, bottom, left
# If there are valid moves available, move into one
if (
self._validMove(cur_row - 1, cur_col)
or self._validMove(cur_row, cur_col + 1)
or self._validMove(cur_row + 1, cur_col)
or self._validMove(cur_row, cur_col - 1)
):
# Mark the current cell we're on as 'tried'
self._markPath(cur_row, cur_col)
# We will now go for one of the next cells
if self._validMove(cur_row - 1, cur_col):
self._path.push((cur_row - 1, cur_col))
self.make_a_move()
elif self._validMove(cur_row, cur_col + 1):
self._path.push((cur_row, cur_col + 1))
self.make_a_move()
elif self._validMove(cur_row + 1, cur_col):
self._path.push((cur_row + 1, cur_col))
self.make_a_move()
elif self._validMove(cur_row, cur_col - 1):
self._path.push((cur_row, cur_col - 1))
self.make_a_move()
# Otherwise, we are at a dead end and must backtrace
else:
self._markTried(self._path.peek()[0], self._path.peek()[1])
self._path.pop()
self.make_a_move()
# Resets the maze by removing all "path" and "tried" tokens.
# def reset( self ):
# ......
# Prints a text-based representation of the maze.
def draw(self):
# For each row
for row, row_ndx in enumerate(range(self.numRows())):
row_display = ""
# Iterate through the number of columns there are
# And then print the (row) value
for col, col_ndx in enumerate(range(self.numCols())):
if self._mazeCells.__getitem__((row_ndx, col_ndx)) == None:
row_display += " "
else:
row_display += str(self._mazeCells.__getitem__((row_ndx, col_ndx)))
print row_display
# Returns True if the given cell position is a valid move.
def _validMove(self, row, col):
return (
row >= 0
and row < self.numRows()
and col >= 0
and col < self.numCols()
and self._mazeCells[row, col] is None
)
# Helper method to determine if the exit was found.
def _exitFound(self, row, col):
return row == self._exitCell.row and col == self._exitCell.col
# Drops a "tried" token at the given cell.
def _markTried(self, row, col):
self._mazeCells.__setitem__((row, col), self.TRIED_TOKEN)
# Drops a "path" token at the given cell.
def _markPath(self, row, col):
self._mazeCells.__setitem__((row, col), self.PATH_TOKEN)
class Maze:
# Define constants to represent contents of the maze cells.
MAZE_WALL = " *"
PATH_TOKEN = " x"
TRIED_TOKEN = " o"
# Creates a maze object with all cells marked as open.
def __init__(self, num_rows, num_cols):
self.stack = Stack()
self._mazeCells = Array2D(num_rows, num_cols)
self._startCell = None
self._exitCell = None
self.st = Stack()
# Returns the number of rows in the maze.
def num_rows(self):
return self._mazeCells.num_rows()
# Returns the number of columns in the maze.
def num_cols(self):
return self._mazeCells.num_cols()
# Fills the indicated cell with a "wall" marker.
def setWall(self, row, col):
assert 0 <= row < self.num_rows() and \
0 <= col < self.num_cols(), "Cell index out of range."
self._mazeCells[row, col] = self.MAZE_WALL
# Sets the starting cell position.
def setStart(self, row, col):
assert 0 <= row < self.num_rows() and \
0 <= col < self.num_cols(), "Cell index out of range."
self._startCell = _CellPosition(row, col)
# Sets the exit cell position.
def setExit(self, row, col):
assert 0 <= row < self.num_rows() and \
0 <= col < self.num_cols(), "Cell index out of range."
self._exitCell = _CellPosition(row, col)
# Method to find neighbour cells
def neighbours(self, _row, _col):
info = []
for coord in [(1, 0), (0, 1), (-1, 0), (0, -1)]:
row, col = _row + coord[0], _col + coord[1]
if self._validMove(row, col):
if not self._mazeCells[row, col]:
info.append(_CellPosition(row, col))
return info
# Attempts to solve the maze by finding a path from the starting cell
# to the exit. Returns True if a path is found and False otherwise.
def findPath(self):
self.stack.push(self._startCell)
while len(self.stack):
current = self.stack.peek()
row, col = current.row, current.col
if self._exitFound(row, col):
self._markPath(row, col)
return True
fine_cells = self.neighbours(row, col)
if fine_cells:
self._markPath(row, col)
for element in fine_cells:
self.stack.push(element)
else:
self._markTried(row, col)
self.stack.pop()
# Resets the maze by removing all "path" and "tried" tokens.
def reset(self):
for row in range(self._mazeCells.num_rows()):
for col in range(self._mazeCells.num_cols()):
if self._mazeCells[row, col] in [" x", " o"]:
self._mazeCells[row, col] = None
# Prints a text-based representation of the maze.
def draw(self):
for row in range(self._mazeCells.num_rows()):
for col in range(self._mazeCells.num_cols()):
if self._mazeCells[row, col]:
print(self._mazeCells[row, col], end=" ")
else:
print(" ", end=" ")
print()
# Returns True if the given cell position is a valid move.
def _validMove(self, row, col):
return 0 <= row < self.num_rows() \
and 0 <= col < self.num_cols() \
and self._mazeCells[row, col] is None
# Helper method to determine if the exit was found.
def _exitFound(self, row, col):
return row == self._exitCell.row and col == self._exitCell.col
# Drops a "tried" token at the given cell.
def _markTried(self, row, col):
self._mazeCells[row, col] = self.TRIED_TOKEN
# Drops a "path" token at the given cell.
def _markPath(self, row, col):
self._mazeCells[row, col] = self.PATH_TOKEN
def find_path(self):
"""
Attempts to solve the maze by finding a path from the starting cell
to the exit. Returns True if a path is found and False otherwise.
"""
path = Stack()
i = self._start_cell.row
j = self._start_cell.col
counter = 0
while True:
check = 0
if self._exit_found(i, j):
for _ in range(len(path)):
coord = path.pop()
self._maze_cells[coord[0], coord[1]] = "x"
self._maze_cells[self._exit_cell.row,
self._exit_cell.col] = "x"
return True
if (self._valid_move(i - 1, j)
and self._maze_cells[i - 1, j] == None and check == 0):
if path.is_empty() or path.peek() != (i - 1, j):
path.push((i, j))
counter = 0
check = 1
i -= 1
elif counter == 1:
self._maze_cells[i, j] = "o"
try:
path.pop()
except AssertionError:
return False
counter = 0
check = 1
i -= 1
else:
counter += 1
if (self._valid_move(i, j + 1)
and self._maze_cells[i, j + 1] == None and check == 0):
if path.is_empty() or path.peek() != (i, j + 1):
path.push((i, j))
counter = 0
check = 1
j += 1
elif counter == 1:
self._maze_cells[i, j] = "o"
try:
path.pop()
except AssertionError:
return False
counter = 0
check = 1
j += 1
else:
counter += 1
if (self._valid_move(i + 1, j)
and self._maze_cells[i + 1, j] == None and check == 0):
if path.is_empty() or path.peek() != (i + 1, j):
path.push((i, j))
counter = 0
check = 1
i += 1
elif counter == 1:
self._maze_cells[i, j] = "o"
try:
path.pop()
except AssertionError:
return False
counter = 0
check = 1
i += 1
else:
counter += 1
if (self._valid_move(i, j - 1)
and self._maze_cells[i, j - 1] == None and check == 0):
if path.is_empty() or path.peek() != (i, j - 1):
path.push((i, j))
counter = 0
check = 1
j -= 1
elif counter == 1:
self._maze_cells[i, j] = "o"
try:
path.pop()
except AssertionError:
return False
counter = 0
check = 1
j -= 1
else:
counter += 1
if check == 0 and counter == 0:
return False
class Maze:
# Define constants to represent contents of the maze cells.
MAZE_WALL = "%" #*
PATH_TOKEN = "." #x
TRIED_TOKEN = "-" #o
# Creates a maze object with all cells marked as open.
def __init__(self, numRows, numCols):
self._mazeCells = Array2D(numRows, numCols)
self._startCell = None
self._exitCell = None
self._path = Stack()
self._path_found = False
# Returns the number of rows in the maze.
def numRows(self):
return self._mazeCells.numRows()
# Returns the number of columns in the maze.
def numCols(self):
return self._mazeCells.numCols()
# Fills the indicated cell with a "wall" marker.
def setWall(self, row, col):
assert row >= 0 and row < self.numRows() and \
col >= 0 and col < self.numCols(), "Cell index out of range."
self._mazeCells.__setitem__((row, col), self.MAZE_WALL)
# Sets the starting cell position.
def setStart(self, row, col):
assert row >= 0 and row < self.numRows() and \
col >= 0 and col < self.numCols(), "Cell index out of range."
self._startCell = _CellPosition(row, col)
# Sets the exit cell position.
def setExit(self, row, col):
assert row >= 0 and row < self.numRows() and \
col >= 0 and col < self.numCols(), \
"Cell index out of range."
self._exitCell = _CellPosition(row, col)
# Attempts to solve the maze by finding a path from the starting cell
# to the exit. Returns True if a path is found and False otherwise.
def findPath(self):
start = (self._startCell.row, self._startCell.col)
end = (self._exitCell.row, self._exitCell.col)
# If start is the same as end, then there's an error
if start == end:
return False
self._path.push(start)
self.make_a_move()
return self._path_found
def make_a_move(self):
# Keep recursion going until stack is empty from not
# finding a path
if self._path._size > 0:
cur_row, cur_col = self._path.peek()
# If the current cell is also the exit cell
# Break out of the recursion and return True!
if self._exitFound(cur_row, cur_col):
self._markPath(cur_row, cur_col)
self._path_found = True
return
# Checks to see if any of the surrounding cells are
# valid to move into- up, right, bottom, left
# If there are valid moves available, move into one
if (self._validMove(cur_row - 1, cur_col) or \
self._validMove(cur_row, cur_col + 1) or \
self._validMove(cur_row + 1, cur_col) or \
self._validMove(cur_row, cur_col - 1)):
# Mark the current cell we're on as 'tried'
self._markPath(cur_row, cur_col)
# We will now go for one of the next cells
if self._validMove(cur_row - 1, cur_col):
self._path.push((cur_row - 1, cur_col))
self.make_a_move()
elif self._validMove(cur_row, cur_col + 1):
self._path.push((cur_row, cur_col + 1))
self.make_a_move()
elif self._validMove(cur_row + 1, cur_col):
self._path.push((cur_row + 1, cur_col))
self.make_a_move()
elif self._validMove(cur_row, cur_col - 1):
self._path.push((cur_row, cur_col - 1))
self.make_a_move()
# Otherwise, we are at a dead end and must backtrace
else:
self._markTried(self._path.peek()[0], self._path.peek()[1])
self._path.pop()
self.make_a_move()
# Resets the maze by removing all "path" and "tried" tokens.
#def reset( self ):
#......
# Prints a text-based representation of the maze.
def draw(self):
# For each row
for row, row_ndx in enumerate(range(self.numRows())):
row_display = ''
# Iterate through the number of columns there are
# And then print the (row) value
for col, col_ndx in enumerate(range(self.numCols())):
if self._mazeCells.__getitem__((row_ndx, col_ndx)) == None:
row_display += ' '
else:
row_display += str(
self._mazeCells.__getitem__((row_ndx, col_ndx)))
print row_display
# Returns True if the given cell position is a valid move.
def _validMove(self, row, col):
return row >= 0 and row < self.numRows() \
and col >= 0 and col < self.numCols() \
and self._mazeCells[row, col] is None
# Helper method to determine if the exit was found.
def _exitFound(self, row, col):
return row == self._exitCell.row and \
col == self._exitCell.col
# Drops a "tried" token at the given cell.
def _markTried(self, row, col):
self._mazeCells.__setitem__((row, col), self.TRIED_TOKEN)
# Drops a "path" token at the given cell.
def _markPath(self, row, col):
self._mazeCells.__setitem__((row, col), self.PATH_TOKEN)
class ExtoPostfix:
"""
Receive an infix expression and turn it into a postfix expression.
This is a helper module of postfixCal.py.
"""
def __init__(self):
self._isp = {
'#': 0,
'(': 1,
'*': 5,
'/': 5,
'+': 3,
'-': 3,
')': 6
} # in stack priority
self._icp = {
'#': 0,
'(': 6,
'*': 4,
'/': 4,
'+': 2,
'-': 2,
')': 1
} # in coming priority
# the list used to save the final postfix expression.
self._postfix = []
# the stack used to change the order of operators.
self._oprtStack = Stack()
def __str__(self):
self._postfix = [
elem for elem in self._postfix if elem != ')' and elem != '('
]
return ','.join(self._postfix)
def _getPostfix(self, expr):
"""
Algorithm:
1)initialize the _oprtStack by pushing '#' into it.
2)read in the first element of the infix expr, and assign it to variable ch.
3)repeat the following steps until ch = '#', meanwhile, the top element of the _oprtStack is also '#':
a)if ch is operand, append it to the _postfix, and read the next ch;
b)if ch is operator, compare the priority(icp) of ch and the priority(isp) of the top element(op) in _oprtStack:
if icp(ch) > isp(op), push ch onto _oprtStack, and read another ch
if icp(ch) < isp(op), pop the top element in _oprtStack, and append it to _postfix
if icp(ch) == isp(op), pop the top element in _oprtStack,if op is '(', read another ch.
"""
expr = expr.split()
self._oprtStack.push('#')
ch = expr.pop(0)
while self._oprtStack.isEmpty() == False and ch != '#':
if ch.isdigit():
self._postfix.append(ch)
ch = expr.pop(0)
else:
ch1 = self._oprtStack.peek()
if self._isp[ch1] < self._icp[ch]:
self._oprtStack.push(ch)
ch = expr.pop(0)
elif self._isp[ch1] > self._icp[ch]:
out = self._oprtStack.pop()
self._postfix.append(out)
else:
out = self._oprtStack.pop()
if out == '(':
ch = expr.pop(0)
for i in range(len(self._oprtStack) - 1):
ch1 = self._oprtStack.pop()
self._postfix.append(ch1)
def backExpr(self, expr):
self._getPostfix(expr)
return self._postfix
