class Translator(object): """Translates infix expressions to postfix expressions.""" def __init__(self, scanner): """Sets the initial state of the translator.""" self._expressionSoFar = "" self._operatorStack = LinkedStack() self._scanner = scanner def translate(self): """Returns a list of tokens that represent the postfix form of sourceStr. Assumes that the infix expression in sourceStr is syntactically correct""" postfix = list() for currentToken in self._scanner: self._expressionSoFar += str(currentToken) + " " if currentToken.getType() == Token.INT: postfix.append(currentToken) elif currentToken.getType() == Token.LPAR: self._operatorStack.push(currentToken) elif currentToken.getType() == Token.RPAR: topOperator = self._operatorStack.pop() while topOperator.getType() != Token.LPAR: postfix.append(topOperator) topOperator = self._operatorStack.pop() else: while not self._operatorStack.isEmpty() 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): """Returns a string containing the contents of the expression processed and the stack to this point.""" 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 translationStatus(self): return str(self)
def brackets_Checker(): stk = LinkedStack() for ch in exp: if ch in ['[', '(']: stk.push(ch) elif ch in [']', ')']: if stk.isEmpty(): return False chFromStack = stk.pop() if ch == ']' and chFromStack != '[' or ch == ')' and chFromStack != '(': return False return stk.isEmpty()
def bracketsBalance(exp): #checks if the parentheses and brackets all match stk = LinkedStack() for l in exp: if l in ['(','[']: stk.push(l) #push opening braces onto the stack elif l in [')',']']: if stk.isEmpty(): return False #the list began with a closing bracket fromStack = stk.pop() if (l == '(' and fromStack != ')') or (l == '[' and fromStack != ']'): return False #non-matching symbols if stk.isEmpty(): return True #they all matched up
def bracketsBalance(exp): """exp is s string that represents the expression""" stk = LinkedStack() for ch in exp: if ch in ["[", "("]: stk.push(ch) elif ch in [']', ')']: if stk.isEmpty(): return False chFromStck = stk.pop() if ch == ']' and chFromStck != '[' or \ ch == ')' and chFromStck != '(' : return False return stk.isEmpty()
def bracketsBalance(exp): """exp is a string that represents the expression """ stk = LinkedStack() for ch in exp: if ch in ['[', '(']: stk.push(ch) elif ch in [']', ')']: if stk.isEmpty(): return False chFromStack = stk.pop() # Brackets must be of same type and match up if ch == ']' and chFromStack != '[' or ch == ')' and chFromStack != '(': return False return stk.isEmpty()
def bracketsBalance(exp): """exp represents the expression""" stk = LinkedStack() # Create a new stack for ch in exp: # Scan across the expression if ch in ['[', '(']: # Push an opening bracket stk.push(ch) elif ch in [']', ')']: # Process a closing bracket if stk.isEmpty(): # Not balanced return False chFromStack = stk.pop() # Brackets must be of same type and match up if ch == ']' and chFromStack != '[' or \ ch == ')' and chFromStack != '(': return False return stk.isEmpty() # They all matched up
def is_palindrome(word: str) -> bool: """Check whether the word is a palindrome.""" stack = LinkedStack() for index, char in enumerate(word, 1): if char.isalpha() and index <= len(word) / 2: stack.push(char) elif char.isalpha() and (index > len(word) / 2) \ and (index != (len(word) / 2) + 0.5): if stack.isEmpty(): return False char_from_stack = stack.pop() if char != char_from_stack: return False return stack.isEmpty()
def node_preorder(self): if not self.isEmpty(): stack = LinkedStack() stack.push(self._root) while not stack.isEmpty(): node = stack.pop() yield node if node.right != None: stack.push(node.right) if node.left != None: stack.push(node.left)
def __iter__(self): """Supports a preorder traversal on a view of self.""" if not self.isEmpty(): stack = LinkedStack() stack.push(self._root) while not stack.isEmpty(): node = stack.pop() yield node.data if node.right is not None: stack.push(node.right) if node.left is not None: stack.push(node.left)
def preorder(self): """Supports a preorder traversal on a view of self.""" if not self.isEmpty(): treeStack = LinkedStack() treeStack.push(self._root) while not treeStack.isEmpty(): node = treeStack.pop() yield node.data if node.right != None: treeStack.push(node.right) if node.left != None: treeStack.push(node.left)
def successor(self, item): """ Returns the smallest item that is larger than item, or None if there is no such item. :param item: :type item: :return: :rtype: """ biggest = 0 if not self.isEmpty(): stack = LinkedStack() stack.push(self._root) while not stack.isEmpty(): node = stack.pop() # print(smallest, node.data) if node.data >= biggest: biggest = node.data if node.right != None: stack.push(node.right) if node.left != None: stack.push(node.left) smallest = biggest # print(smallest) if not self.isEmpty(): stack = LinkedStack() stack.push(self._root) while not stack.isEmpty(): node = stack.pop() # print(smallest, node.data) if item <= node.data <= smallest: smallest = node.data if node.right != None: stack.push(node.right) if node.left != None: stack.push(node.left) # print(smallest) return smallest if smallest != 0 else None
def levelorder(self): """Supports a levelorder traversal on a view of self.""" if not self.isEmpty(): stack = LinkedStack() stack.push(self.root) yield self.root.data while not stack.isEmpty(): node = stack.pop() if node.left != None: yield node.left.data stack.push(node.right) if node.right != None: yield node.right.data stack.push(node.left)
def mazeSolver(maze, start, to_text=False, data_structure='stack'): """takes a maze and its starting point (as a tuple of row, column) and solves the maze. Maze walls must be * characters and the ending point must be a "T" character. Free spaces must be an empty space, " ". """ # read the grid and set up stack grid = maze_reader(maze) print("maze without attempts:\n", grid) if data_structure == 'stack': _queue = LinkedStack() else: _queue = LinkedQueue( ) #TODO implement a linkedQueue structure with push _queue.push(start) # track choices: choice_count = 0 #use stack data structure to explore maze and find a path to the end. while not _queue.isEmpty(): _pop = _queue.pop() # print("popping ",_pop) if grid[_pop[0]][_pop[1]] == 'T': choice_count += 1 print("Finished maze: \n") print(grid) if to_text: maze_text(grid, "solution.txt") return choice_count else: # if the _pop location did not return the character "T", leave a breadcrumb to not revisit. if grid[_pop[0]][_pop[1]] != 'O' and grid[_pop[0]][ _pop[1]] != 'T' and grid[_pop[0]][_pop[1]] != 'P': choice_count += 1 grid[_pop[0]][_pop[1]] = 'O' # print("grid row, column is ",_pop[0],_pop[1],"\n") # print(grid) left = grid[_pop[0]][(_pop[1] - 1)] right = grid[_pop[0]][(_pop[1] + 1)] down = grid[(_pop[0] - 1)][_pop[1]] up = grid[(_pop[0] + 1)][_pop[1]] if left == ' ' or left == 'T': _queue.push((_pop[0], (_pop[1] - 1))) if right == ' ' or right == 'T': _queue.push((_pop[0], (_pop[1] + 1))) if up == ' ' or up == 'T': _queue.push(((_pop[0] + 1), _pop[1])) if down == ' ' or down == 'T': _queue.push(((_pop[0] - 1), _pop[1])) #if stack becomes empty, there is no path. return choice_count
class Polindrom(LinkedStack): """docstring for Polindrom.""" def __init__(self): self.dictionary = LinkedStack() self.polindroms = [] def read_dict(self, filename): """reads data from file and saves it to dictionary""" with open(filename, encoding='utf-8', errors='ignore') as f: lines = f.readlines() if ".lst" in filename: for line in lines: self.dictionary.push(line.split()[0]) # counter = 0 # with open("try.txt", "w") as t: # while counter < 30: # t.write(lines[counter].split()[0]+"\n") # counter += 1 # self.dictionary.push(line.strip()) else: for line in lines: self.dictionary.push(line.strip()) def process_dict(self): """looks for polindroms in processed dict and returns a list of them""" while not self.dictionary.isEmpty(): isPolindrom = True curr_word = self.dictionary.pop() curr_word_len = len(curr_word) if curr_word_len > 1: for i in range(curr_word_len // 2): if curr_word[i].lower() == curr_word[ curr_word_len - i - 1].lower() and isPolindrom: isPolindrom = True else: isPolindrom = False if isPolindrom: self.polindroms.append(curr_word) def write_dict(self, filename): """writes data from polindroms to file""" with open(filename, "w", encoding='utf-8', errors='ignore') as f: for item in self.polindroms: f.write(item) f.write("\n")
def successor(self, item): #FIXME: Incomplete succ = LinkedStack() def recurse(node, item): if node != None: if item >= node.data: recurse(node.right, item) elif item < node.data: succ.push(node.data) recurse(node.left, item) if self.isEmpty(): return None else: recurse(self.root, item) result = None if not succ.isEmpty(): result = succ.pop() return result
def predecessor(self, item): pred = LinkedStack() def recurse(node, item): if node != None: if item <= node.data: recurse(node.left, item) elif item > node.data: pred.push(node.data) recurse(node.right, item) if self.isEmpty(): return None else: recurse(self.root, item) result = None if not pred.isEmpty(): result = pred.pop() return result
def predecessor(self, item): """ Returns the largest item that is smaller than item, or None if there is no such item. :param item: :type item: :return: :rtype: """ biggest = 0 if not self.isEmpty(): stack = LinkedStack() stack.push(self._root) while not stack.isEmpty(): node = stack.pop() if biggest <= node.data <= item: biggest = node.data if node.right != None: stack.push(node.right) if node.left != None: stack.push(node.left) return biggest if biggest != 0 else None
def rangeFind(self, low, high): ''' Returns a list of the items in the tree, where low <= item <= high.""" :param low: :param high: :return: ''' lst = [] if not self.isEmpty(): stack = LinkedStack() stack.push(self._root) while not stack.isEmpty(): node = stack.pop() if low <= node.data <= high: lst.append(node.data) if node.right != None: stack.push(node.right) if node.left != None: stack.push(node.left) return lst
"""
def liclear_unit_test(self): temp = LinkedStack() for count in range(4): temp.push(count+1) temp.clear() self.assertEqual(temp.isEmpty(), True)