def infix_to_potfix(token_list):
"""
들어온 중위 표현식을 후위 표현식으로 변경
:param token_list:
:return: 후위 표현식
"""
prec = {'*': 3, '/': 3, '+': 2, '-': 2, '(': 1}
opStack = ArrayStack()
result = []
for token in token_list:
if isinstance(token, int):
result.append(token)
elif token == '(':
opStack.push(token)
elif token == ')':
while opStack.peek() != '(':
result.append(opStack.pop())
opStack.pop()
else:
if not opStack.isEmpty():
if prec[opStack.peek()] >= prec[token]:
result.append(opStack.pop())
opStack.push(token)
else:
opStack.push(token)
else:
opStack.push(token)
while not opStack.isEmpty():
result.append(opStack.pop())
print(result)
return result
def solveMaze(row, column, maze):
stack = ArrayStack()
stack.push((row, column))
while not stack.isEmpty():
(row, column) = stack.peek()
if maze[row][column] == 'T':
return stack
elif maze[row][column] != '.':
maze[row][column] = '.'
counter = 0 ###adjacent cells based on changing x,y values so need 4 options
if row != 0 and not maze[row - 1][column] in ('*', '.'):
stack.push((row-1, column))
counter += 1
if row + 1 != maze.getHeight() and not maze[row + 1][column] in ('*', '.'):
stack.push((row + 1, column))
counter += 1
if column + 1 != maze.getWidth() and not maze[row][column + 1] in ('*', '.'):
stack.push((row, column + 1))
counter += 1
if column != 0 and not maze[row][column -1] in ('*', '.'):
stack.push((row, column - 1))
counter += 1
if counter == 0:
stack.pop()
return None
class PFEvaluator(object):
def __init__(self, scanner):
self._expressionSoFar = ""
self._operandStack = ArrayStack()
self._scanner = scanner
def evaluate(self):
while self._scanner.hasNext():
currentToken = self._scanner.next()
self._expressionSoFar += str(currentToken) + " "
if currentToken.getType() == Token.INT:
self._operandStack.push(currentToken)
elif currentToken.isOperator():
if len(self._operandStack) < 2:
raise Exception, \
"Too few operands on the stack"
t2 = self._operandStack.pop()
t1 = self._operandStack.pop()
result = Token(self._computeValue(currentToken,
t1.getValue(),
t2.getValue()))
self._operandStack.push(result)
else:
raise Exception, "Unknown token type"
if len(self._operandStack) > 1:
raise Exception, "Too many operands on the stack"
result = self._operandStack.pop()
return result.getValue();
def __str__(self):
result = "\n"
if self._expressionSoFar == "":
result += "Portion of expression processed: none\n"
else:
result += "Portion of expression processed: " + \
self._expressionSoFar + "\n"
if self._operandStack.isEmpty():
result += "The stack is empty"
else:
result += "Operands on the stack : " + \
str(self._operandStack)
return result
def _computeValue(self, op, value1, value2):
result = 0;
theType = op.getType()
if theType == Token.PLUS:
result = value1 + value2;
elif theType == Token.MINUS:
result = value1 - value2;
elif theType == Token.MUL:
result = value1 * value2;
elif theType == Token.DIV:
result = value1 / value2;
else:
raise Exception, "Unknown operator"
return result
class PFEvaluator(object):
def __init__(self, scanner):
self._expressionSoFar = ""
self._operandStack = ArrayStack()
self._scanner = scanner
def evaluate(self):
while self._scanner.hasNext():
currentToken = self._scanner.next()
self._expressionSoFar += str(currentToken) + " "
if currentToken.getType() == Token.INT:
self._operandStack.push(currentToken)
elif currentToken.isOperator():
if len(self._operandStack) < 2:
raise Exception, \
"Too few operands on the stack"
t2 = self._operandStack.pop()
t1 = self._operandStack.pop()
result = Token(
self._computeValue(currentToken, t1.getValue(),
t2.getValue()))
self._operandStack.push(result)
else:
raise Exception, "Unknown token type"
if len(self._operandStack) > 1:
raise Exception, "Too many operands on the stack"
result = self._operandStack.pop()
return result.getValue()
def __str__(self):
result = "\n"
if self._expressionSoFar == "":
result += "Portion of expression processed: none\n"
else:
result += "Portion of expression processed: " + \
self._expressionSoFar + "\n"
if self._operandStack.isEmpty():
result += "The stack is empty"
else:
result += "Operands on the stack : " + \
str(self._operandStack)
return result
def _computeValue(self, op, value1, value2):
result = 0
theType = op.getType()
if theType == Token.PLUS:
result = value1 + value2
elif theType == Token.MINUS:
result = value1 - value2
elif theType == Token.MUL:
result = value1 * value2
elif theType == Token.DIV:
result = value1 / value2
else:
raise Exception, "Unknown operator"
return result
def bracketsBalance(exp, Open, Close):
"""exp represents the expression"""
stk = ArrayStack() # Create a new stack
for ch in exp: # Scan across the expression
if ch in Open: # Push an opening bracket
stk.push(ch)
elif ch in Close: # Process a closing bracket
if stk.isEmpty(): # Not balanced
return False
chFromStack = stk.pop()
# Brackets must be of same type and match up
OpenIndex = Open.index(chFromStack)
CloseIndex = Close.index(ch)
if OpenIndex != CloseIndex:
return False
return stk.isEmpty() # They all matched up
def multiBaseOutput(num, b):
stk = ArrayStack()
s1 = ''
while num != 0:
stk.push(str(num % b))
num = num // b
while not stk.isEmpty():
s1 += stk.pop()
return s1
def is_brackets(expr):
match = {
')':'(',
']':'[',
'}':'{'
}
S = ArrayStack()
for c in expr:
if c in '({[':
S.push(c)
else:
if S.isEmpty():
return False
else:
bracket = S.pop()
if bracket != match[c]:
return False
return S.isEmpty() # 스택이 비어있지 않으면 괄호가 안맞음.
def maze_solver(maze, starting_pt, target_pt):
"""Implement backtracking algorithms using a stack to solve a maze"""
if_solvable = False
maze_stack = ArrayStack()
path = {}
maze_stack.push(starting_pt)
while not maze_stack.isEmpty():
location = maze_stack.pop()
if maze[location[0]][location[1]] == 'T':
if_solvable = True
elif maze[location[0]][location[1]] != '.':
maze[location[0]][location[1]] = '.'
nrs = check_neighbours(maze, location[0], location[1])
for nr in nrs:
maze_stack.push(nr)
path[nr] = location
return if_solvable, path
