def getOut(row, column, maze):
"""(row,column) is the position of the start symbol in the maze.
Returns True if the maze can be solved or False otherwise."""
# States are tuples of coordinates of cells in the grid.
stack = ArrayStack()
stack.push((row,column))
while not stack.isEmpty():
if maze[row][column] == 'T':
return True
else:
# Try NORTH
if row != 0 and not maze[row - 1][column] in ('*', '.'):
stack.push((row - 1, column))
maze[row-1][column] = '.'
# Try SOUTH
elif row != maze.getHeight() and not maze[row + 1][column] in('*','.'):
stack.push((row + 1, column))
maze[row+1][column] = '.'
# Try EAST
elif column != maze.getWidth() and not maze[row][column + 1] in('*','.'):
stack.push((row,column + 1))
maze[row][column + 1] = '.'
# Try WEST
elif column != 0 and not maze[row][column - 1] in ('*','.'):
stack.push((row,column - 1))
maze[row][column - 1] = '.'
return False
def find_palindromes(self, file, file_name):
"""
method which finds palindroms.
"""
words_list = self.read_file(file)
stack = ArrayStack()
result = []
for word in words_list:
word_len = len(word)
if word_len == 1.0:
result.append(word)
else:
word_mid = word_len // 2
middle = word_len % 2
for i in range(word_len):
if i < word_mid:
stack.push(word[i])
elif middle == 1 and i == word_mid:
continue
else:
if stack.pop() != word[i]:
check = False
break
check = True
if check is True:
result.append(word)
self.write_to_file(result, file_name)
return result
def find_palindromes(self, input_file, output_file):
'''
Find palindromes using stack
'''
palindroms = []
self.input_file = input_file
self.output_file = output_file
words = self.read_file(self.input_file)
for word in words:
word_lst = list(word)
word_stack = ArrayStack()
flag = True
for letter in range(len(word_lst)-1, -1, -1):
word_stack.push(word[letter])
while not word_stack.isEmpty():
if word_stack.pop() != word_lst.pop():
flag = False
break
if flag:
palindroms.append("".join(word))
self.write_to_file(self.output_file, palindroms)
return palindroms
def arremstor_unit_test(self):
temp = ArrayStack()
for count in range(20):
temp.push(count+1)
for count in range(15):
temp.pop()
self.assertEqual(len(temp.items), 10)
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;
elif theType == Token.EXP:
result = value1 ** value2;
else:
raise Exception("Unknown operator")
return result
class PFEvaluator(object):
def __init__(self, scanner):
self._expression_so_far = ""
self._operand_stack = ArrayStack()
self._scanner = scanner
def evaluate(self):
while self._scanner.has_next():
current_token = self._scanner.next()
self._expression_so_far += str(current_token) + " "
if current_token.get_type() == Token.INT: # 数字入栈
self._operand_stack.push(current_token)
elif current_token.is_operator(): # 操作符计算
if len(self._operand_stack) < 2: # 栈内数字小于2
raise AttributeError (\
"Too few operands on the stack")
t2 = self._operand_stack.pop()
t1 = self._operand_stack.pop()
result = \
Token(self._compute_value(current_token,
t1.get_value(),
t2.get_value()))
self._operand_stack.push(result)
else:
raise AttributeError("Unknown token type")
if len(self._operand_stack) > 1: # 计算完成后, 栈内深入数字大于2
raise AttributeError(\
"Too many operands on the stack")
result = self._operand_stack.pop()
return result.get_value()
def __str__(self):
result = "\n"
if self._expression_so_far == "":
result += \
"Portion of expression processed none\n"
else:
result += "Portion of expression processed: " + \
self._expression_so_far + "\n"
if self._operand_stack.isEmpty():
result += "Thre stack is empty"
else:
result += "Operands on the stack: " + \
str(self._operand_stack)
return result
def _compute_value(self, op, value1, value2):
result = 0
the_type = op.get_type()
if the_type == Token.PLUS:
result = value1 + value2
elif the_type == Token.MINUS:
result = value1 - value2
elif the_type == Token.MUL:
result = value1 * value2
elif the_type == Token.DIV:
result = value1 // value2
else:
raise AttributeError("Unknown operator")
return result
def test_arraystack_popallthrowsempty(self):
stack = ArrayStack()
for i in range(100):
stack.push(i + 1)
for i in range(100):
stack.pop()
stack.pop()
def getOut(row, column, maze):
"""(row,column) is the position of the start symbol in the maze.
Returns True if the maze can be solved or False otherwise."""
# States are tuples of coordinates of cells in the grid.
stack = ArrayStack()
stack.push((row, column))
while not stack.isEmpty():
(row, column) = stack.pop()
if maze[row][column] == 'T':
return True
elif maze[row][column] != '.':
# Cell has not been visited, so mark it and push adjacent unvisited
# positions onto the stack
maze[row][column] = '.'
# Try NORTH
if row != 0 and not maze[row - 1][column] in ('*', '.'):
stack.push((row - 1, column))
# Try SOUTH
if row + 1 != maze.getHeight() and not maze[row + 1][column] in ('*', '.'):
stack.push((row + 1, column))
# Try EAST
if column + 1 != maze.getWidth() and not maze[row][column + 1] in ('*', '.'):
stack.push((row, column + 1))
# Try WEST
if column != 0 and not maze[row][column - 1] in ('*', '.'):
stack.push((row, column - 1))
return False
def is_matched_html(raw):
"""Return True if all HTML tags are properly matched;
False Otherwise."""
S = ArrayStack()
# find first '<' character
start = raw.find('<')
while start != -1:
# find next '>' character
end = raw.find('>', start + 1)
if end == -1:
return False
# strip away < >
tag = raw[start + 1:end]
# this is opening tag
if not tag.startswith('/'):
S.push(tag)
# this is closing tag
else:
if S.is_empty():
return False
if tag[1:] != S.pop():
return False
start = raw.find('<', end + 1)
# all tags matched
return S.is_empty()
def find_palindromes(self, read_from: str, write_to: str) -> list:
"""
Finds all palindromes from the file and
write it into another one
Returns a list with palindromes
"""
words = self.read_file(read_from)
palindromes = list()
stack_with_words = ArrayStack()
reversed_word = ""
for word in words:
for char in word:
stack_with_words.push(char)
while not stack_with_words.isEmpty():
reversed_word += stack_with_words.pop()
if reversed_word == word:
palindromes.append(word)
reversed_word = ""
self.write_in_file(write_to, palindromes)
return palindromes
def convert(self):
operatorStack = ArrayStack() #this will hold operators and grouping symbols
postfixExpression = "" #this will hold the final expression
while self.scanner.hasNext():
token_char = self.scanner.next()
if token_char.getType() == 4: #it's an integer
postfixExpression += str(token_char.getValue()) + " "
elif token_char.getValue() in ['(','[']: #left parenthesis
operatorStack.push(token_char)
elif token_char.isOperator(): #it's an operator
#pop off all the operators with equal or greater precedence
while len(operatorStack) != 0 and operatorStack.peek().getPrecedence() >= token_char.getPrecedence():
postfixExpression += str(operatorStack.pop().getValue()) + " "
#now we can push the new operator onto the stack
operatorStack.push(token_char)
elif token_char.getValue() in [')',']']: #right parenthesis
while len(operatorStack) != 0 and operatorStack.peek().getValue() not in ['(','[']: #find the matching one
postfixExpression += str(operatorStack.pop().getValue()) + " "
operatorStack.pop() #discard the left parenthesis
elif token_char.getType() == 0 and token_char.getValue() not in ['(',')','[',']']:
raise Exception("Error: unknown character.") #unknown character
#transfer over any remaining operators
while len(operatorStack) != 0:
postfixExpression += str(operatorStack.pop().getValue()) + " "
return postfixExpression
def convert(self):
"""Returns a list of tokens that represent the postfix
form. Assumes that the infix expression is syntactically correct"""
postfix = []
stack = ArrayStack()
while self._scanner.hasNext():
currentToken = self._scanner.next()
if currentToken.getType() == Token.INT:
postfix.append(currentToken)
elif currentToken.getType() == Token.LPAR:
stack.push(currentToken)
elif currentToken.getType() == Token.RPAR:
topOperator = stack.pop()
while topOperator.getType() != Token.LPAR:
postfix.append(topOperator)
topOperator = stack.pop()
else:
while not stack.isEmpty() and \
currentToken.getType() != Token.EXPO and \
stack.peek().getPrecedence() >= currentToken.getPrecedence():
postfix.append(stack.pop())
stack.push(currentToken)
while not stack.isEmpty():
postfix.append(stack.pop())
return postfix
def lipop_unit_test(self):
temp = ArrayStack()
for count in range(4):
temp.push(count+1)
temp.pop()
self.assertEqual(temp.peek(), 3)
temp.pop()
self.assertEqual(len(temp),2)
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 AttributeError("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 AttributeError("Unknown token type")
if len(self._operandStack) > 1:
raise AttributeError("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 IFToPFConverter(object):
def __init__(self, scanner):
self._expressionSoFar = ""
self._operatorStack = ArrayStack()
self._scanner = scanner
def convert(self):
"""Returns a list of tokens that represent the postfix
form of sourceStr. Assumes that the infix expression
in sourceStr is syntactically correct"""
postfix = []
while self._scanner.hasNext():
currentToken = self._scanner.next()
self._expressionSoFar += str(currentToken) + " "
if currentToken.getType() == Token.UNKNOWN:
raise AttributeError("Unrecognized symbol")
if currentToken.getType() == Token.INT:
postfix.append(currentToken)
elif currentToken.getType() == Token.LPAR:
self._operatorStack.push(currentToken)
elif currentToken.getType() == Token.RPAR:
if self._operatorStack.isEmpty():
raise AttributeError("Too few operators")
topOperator = self._operatorStack.pop()
while topOperator.getType() != Token.LPAR:
postfix.append(topOperator)
if self._operatorStack.isEmpty():
raise AttributeError("Too few operators")
topOperator = self._operatorStack.pop()
else:
while not self._operatorStack.isEmpty() and \
currentToken.getType() != Token.EXPO and \
self._operatorStack.peek().getPrecedence() >= currentToken.getPrecedence():
postfix.append(self._operatorStack.pop())
self._operatorStack.push(currentToken)
while not self._operatorStack.isEmpty():
postfix.append(self._operatorStack.pop())
return postfix
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._operatorStack.isEmpty():
result += "The stack is empty"
else:
result += "Operators on the stack : " + \
str(self._operatorStack)
return result
def conversionStatus(self):
return str(self)
def test_stack():
S = ArrayStack()
S.push(5)
print(S.top())
S.push(6)
print(len(S))
print(S.pop())
print(S.is_empty())
print(S.data)
def isPalindrome(string):
"""Returns True if string is a palindrome
or False otherwise."""
stk = ArrayStack()
for ch in string:
stk.push(ch)
for ch in string:
if ch != stk.pop():
return False
return True
def queue_to_stack(queue):
'''Convert queue to stack, without modifying the queue
peek of the stack must be first element of the queue'''
stack = ArrayStack()
queue_copy = ArrayQueue(queue)
while len(queue_copy) != 0:
stack.push(queue_copy.remove(len(queue_copy) - 1))
return stack
class PFEvaluator(object):
def __init__(self, postfix):
self._expressionSoFar = ""
self._operandStack = ArrayStack()
self._postfix = postfix
def evaluate(self):
for currentToken in self._postfix:
self._expressionSoFar += str(currentToken) + " "
if currentToken.getType() == Token.INT:
self._operandStack.push(currentToken)
else:
t2 = self._operandStack.pop()
t1 = self._operandStack.pop()
result = Token(self._computeValue(currentToken,
t1.getValue(),
t2.getValue()))
self._operandStack.push(result)
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:
if value2 == 0:
raise ZeroDivisionError("Attempt to divide by 0")
result = value1 // value2;
elif theType == Token.EXPO:
result = value1 ** value2;
else:
raise AttibuteError("Unknown operator")
return result
def check_palindrome(s):
s = str(s)
stack = ArrayStack()
even = 1 if len(s) % 2 else 0
half = len(s) // 2
for i in range(half):
stack.push(s[i])
ind = half + even
for i in range(half):
if stack.pop() != s[ind + i]:
return False
return True
def queue_to_stack(queue):
"""
Converts queue to stack.
"""
list_queue = []
for i in queue.__iter__():
list_queue.append(i)
list_stack = list_queue[::-1]
new_stack = ArrayStack()
for j in range(len(list_queue)):
new_stack.push(list_stack[j])
return new_stack
def queue_to_stack(queue):
'''
Conver queue to stack.
'''
queue_copy = deepcopy(queue)
stack = ArrayStack()
while queue_copy:
stack.push(queue_copy.pop())
result = ArrayStack()
while stack:
result.push(stack.pop())
return result
def stack_to_queue(stack):
"""
Converts stack to queue.
"""
temp_stack = ArrayStack()
result_queue = ArrayQueue()
while not stack.isEmpty():
elem = stack.pop()
result_queue.add(elem)
temp_stack.push(elem)
while not temp_stack.isEmpty():
stack.push(temp_stack.pop())
return result_queue
def check_brackets(s):
stack = ArrayStack()
for i in s:
if i == "(":
stack.push("(")
if i == ")":
if stack.isEmpty():
return False
stack.pop()
if stack.isEmpty():
return True
else:
return False
def stack_to_queue(stack):
"""
Return queue from stack (front of queue is peek of stack).
"""
copy_stack = ArrayStack()
queue = ArrayQueue()
for element in stack:
copy_stack.push(element)
while len(copy_stack) != 0:
queue.add(copy_stack.pop())
return queue
def queue_to_stack(queue):
"""
Converts the queue to a stack.
"""
stk_ar = ArrayStack()
q = ArrayQueue(queue)
el = []
while not q.isEmpty():
el.append(q.pop())
q1 = ArrayQueue(el[::-1])
while not q1.isEmpty():
stk_ar.push(q1.pop())
return stk_ar
def queue_to_stack(queue):
"""
Convert queue to stack
"""
stack1 = ArrayStack()
stack2 = ArrayStack()
while len(queue) != 0:
num = queue.pop()
stack1.push(num)
while len(stack1) != 0:
num = stack1.pop()
stack2.push(num)
return stack2
def is_matched(expr):
"""Return True if all delimiters properly match (or closed); False otherwise"""
left_delimiters = "({["
right_delimiter = ")}]"
S = ArrayStack()
for c in expr:
if c in left_delimiters:
S.push(c)
elif c in right_delimiter:
if S.is_empty():
return False
if right_delimiter.index(c) != left_delimiters.index(S.pop()):
return False
return S.is_empty()
def checkBalance(st):
stck = ArrayStack()
for i in st:
if i == '[' or i == '{' or i == '(':
stck.push(i)
else:
if i == ']' or i == '}' or i == ')':
if stck.isEmpty() or stck.peek() != opposite(i):
return False
else:
stck.pop()
if stck.isEmpty():
return True
return False
def reverse_file(filename):
"""Overwrite a given file with contents line-by-line in reversed order"""
S = ArrayStack()
original = open(filename)
for line in original:
S.push(line.rstrip('\n')) # we will re-insert newlines while writing
original.close()
# now write the contents in LIFO order
output = open(filename, 'w')
while not S.is_empty():
output.write(S.pop() + '\n') # add trailing new line
output.close()
def palindrome_search(line):
"""
The function returns True if the word is a palindrome
"""
s = ArrayStack()
for letter in line:
s.push(letter)
reversed_line = ''
while not s.isEmpty():
reversed_line += s.pop()
if line == reversed_line:
return True
else:
return False
def is_match(expr):
"""Return True if all the delimiters are properly matched; False Otherwise;"""
lefty = '({['
righty = ')}]'
stack = ArrayStack()
for c in expression:
if c in lefty:
stack.push(c)
elif c in righty:
if stack.is_empty():
return False
if righty.index(c) != lefty.index(stack.pop()):
return False
return stack.is_empty()
def infixToPostfix(exp):
stck = ArrayStack()
postfix = ""
for i in range(len(exp)):
if isOperand(exp[i]):
postfix += exp[i]
else:
if stck.isEmpty():
stck.push(exp[i])
else:
if prec(exp[i]) >= prec(stck.peek()):
stck.push(exp[i])
else:
while not stck.isEmpty() and prec(exp[i]) < prec(stck.peek()):
postfix += stck.pop()
stck.push(exp[i])
# print "Stack:", stck.printStack(), "Expression:", postfix
while not stck.isEmpty():
postfix += stck.pop()
return postfix
