def minRemoveToMakeValid(self, s: str) -> str: s = list(s) par_mapping = {')': '(', ']': '[', '}': '{'} open_par = set(par_mapping.values()) stack = [] for i, char in enumerate(s): if char in open_par: stack.append(i) elif char in par_mapping: if stack: expected = par_mapping[char] if s[stack[-1]] == expected: stack.pop() else: s[i] = '' else: s[i] = '' while stack: s[stack[-1]] = '' stack.pop() return ''.join(s)
def parentheses(s): stack = [] for ch in s: if stack and is_sym(ch, stack[len(stack) - 1]): stack.pop() else: stack.append(ch) if stack: return False return True
def dfs_matrix_rec_path_two(self, map, graph, stack, visited, goal): if stack: last_path = stack.pop() last_node = last_path[-1] if last_node not in visited: visited.append(last_node) if last_node == goal: print('->'.join(last_path)) return last_path current_node_key = -1 for key, value in map.items(): if value == last_node: current_node_key = key neighbours_loc = graph[current_node_key] index = 0 while index < len(neighbours_loc): if neighbours_loc[index] == 1: neighbour = map[index] if neighbour not in visited: new_last_path = list(last_path) new_last_path.append(neighbour) stack.append(new_last_path) index += 1 self.dfs_matrix_rec_path_two(map, graph, stack, visited, goal) else: print('Cant find goal')
def cal(self, stack): operators = [] result = 0 current_num = 0 while stack: c = stack.pop() if c.isdigit(): current_num = current_num * 10 + int(c) else: if current_num != 0 and not operators: result = current_num current_num = 0 if c == "+" or c == "-": if operators: result = caculate(result, operators.pop(), current_num) current_num = 0 operators.append(c) else: operators.append(c) elif c == "(": if operators: result = caculate(result, operators.pop(), self.cal(stack)) else: result = self.cal(stack) elif c == ")": break if operators: result = caculate(result, operators.pop(), current_num) elif not result: return current_num return result
def depthFirstSearch(problem): """ Search the deepest nodes in the search tree first. Your search algorithm needs to return a list of actions that reaches the goal. Make sure to implement a graph search algorithm. To get started, you might want to try some of these simple commands to understand the search problem that is being passed in: print "Start:", problem.getStartState() """ "*** YOUR CODE HERE ***" start = problem.getStartState() #present state stack = util.Stack( ) #stack to hold present state and directions from Start state visited_set = [] # list containing all visited nodes start_dir = [] # Entire path from start to the goal path while (problem.isGoalState(start) != True): successors = problem.getSuccessors(start) start_dir_len = len(start_dir) for l, m, n in successors: temp = start_dir[0:start_dir_len] temp.append(m) stack.push((l, temp)) while True: start, start_dir = stack.pop( ) #Getting the successor to be explored and the directions from start node if start not in visited_set: #If the successor is in the visited set get the next successor visited_set.append(start) break return start_dir
def dfs_expand_path(self, graph, stack, visited): if stack: last_node = stack.pop() if last_node not in visited: visited.append(last_node) neighbours = graph[last_node] for neighbour in neighbours: if neighbour not in visited: stack.append(neighbour) self.dfs_expand_path(graph, stack, visited) else: print('->'.join(visited))
def string_reverse(string): stack = Stack() start, start_ = 0, 0 reversed_str = "" while start < len(string): index = string[start] stack.push(index) start += 1 while start_ < len(string): reversed_str += stack.pop() start_ += 1 return reversed_str
def remove_loops(dg): rm = [] visited = set() path = [object()] path_set = set(path) stack = [iter(dg)] while stack: for v in stack[-1]: if v in path_set: rm.append((path[-1], v)) elif v not in visited: visited.add(v) path.append(v) path_set.add(v) stack.append(iter(dg[v])) break else: path_set.remove(path.pop()) stack.pop() # print(rm) dg.remove_edges_from(rm) return dg
def dfs_graph_vetex(self, graph, root): visited = [] stack = [root] while stack: vertex = stack.pop() if vertex not in visited: visited.append(vertex) neighbours = graph[vertex] for neighbour in neighbours: if neighbour not in visited: stack.append(neighbour) print('->'.join(visited))
def inorderTraversal2(self, root): if not root: return [] list, stack = [], [] while root or stack: while root: stack.append(root) root = root.left root = stack.pop() list.append(root.val) root = root.right return list pass
def preorderTraversal4(self, root): if not root: return [] list = [] stack = [] while root: list.append(root.val) if root.right: stack.append(root.right) root = root.left if not root and stack: root = stack.pop() return list
def preorderTraversal3(self, root): if not root: return [] list = [] stack = [] stack.append(root) while stack: node = stack.pop() list.append(node.val) if node.right: stack.append(node.right) if node.left: stack.append(node.left) return list pass
def dfs_goal_path(self, graph, stack, visited, goal): if stack: last_path = stack.pop() last_node = last_path[-1] if last_node == goal: print('->'.join(last_path)) return last_path if last_node not in visited: visited.append(last_node) neighbours = graph[last_node] for neighbour in neighbours: if neighbour not in visited: new_last_path = list(last_path) new_last_path.append(neighbour) stack.append(new_last_path) self.dfs_goal_path(graph, stack, visited, goal)
def dfs_path_goal(self, graph, root, goal): visited = [] stack = [root] while stack: last_path = stack.pop() last_node = last_path[-1] if last_node == goal: print('->'.join(last_path)) return last_path if last_node not in visited: visited.append(last_node) for neighbour in graph[last_node]: if neighbour not in visited: new_path = list(last_path) new_path.append(neighbour) stack.append(new_path)
def isLeagal(str): stack = [] A = ['[', '(', '{'] B = [']', ')', '}'] for s in str: if s in A: stack.append(s) else: if len(stack) > 0: a = stack.pop() if isPair(a, s, A, B): continue else: return False else: return False if len(stack) > 0: return False return True
def dfs_extendpath_rec_matrix(self, map, graph, stack, visited): if stack: last_node = stack.pop() if last_node not in visited: visited.append(last_node) current_node_key = -1 for key, value in map.items(): if value == last_node: current_node_key = key neighbours_loc = graph[current_node_key] index = 0 while index < len(neighbours_loc): if neighbours_loc[index] == 1: neighbour = map[index] if neighbour not in visited: stack.append(neighbour) index += 1 self.dfs_extendpath_rec_matrix(map, graph, stack, visited) else: print('->'.join(visited))
def isValid(self, s): """ :type s: str :rtype: bool """ p_table = {"(": ")", "[": "]", "{": "}"} stack = [] for c in s: print(f'{c}') # 左括號押入 stack if c in p_table.keys(): stack.append(c) else: # 右括號, 取出 stack popUp 的左括號 pop_c = stack.pop() # 檢查 popUp 的左括號對應的右括號是否相同 if c != p_table[pop_c]: return False # 如果 stack 不為空, 代表 s 為不合法字串 return not stack
self._content.append(v) self._current = self._current + 1 else: print('Stack Full!') def pop(self): if self._content: self._current = self._current - 1 return self._content.pop() else: print('Stack empty!') def show(self): print(self._content) def showRemainderSpace(self): print('Stack can still push ', self._size-self._current, 'elements.') if __name__ == '__main__': print('Please use me as a module.') stack = myStack(10) for i in range(1,6): stack.push(i) stack.show() stack.showRemainderSpace(); for i in range(0,4): stack.pop() print(stack.isEmpty()) stack.show(); stack.pop() print(stack.isEmpty())
@author: HP ''' #TODO: create a stack from inspect import stack stack = [] #TODO: insert items into stack stack.append(1) stack.append(2) stack.append(3) stack.append(4) #TODO: print the stack print(stack) #TODO: find element in a stack def find(val): if val in stack: print('value found', val) else: print('value not found', val) #TODO: delete an item x = stack.pop() print(x) print(stack) find(4)
def test_pop_raise_empty(): # 7 stack = Stack() actual = stack.pop() expected = 'empty stack' assert actual == expected