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