def main(): my_stack = Stack() for _ in range(10): my_stack.push(randint(0, 9)) sort_stack(my_stack) for _ in range(10): print my_stack.pop()
class StackWithMin(object): def __init__(self, top = None): self.top = top #store the min values self._min = Stack(top) def min(self): retval = self._min.peek() if retval is None: retval = sys.maxsize return retval def push(self,data): new_node = Node(data, self.top) self.top = new_node if data <= self.min(): self._min.push(data) def pop(self): if self.top: retval = Node(self.top.data) self.top = self.top.next if retval.data == self.min(): self._min.pop() return retval def peek(self): if self.top: return self.top.data
def solution(self): stck = Stack() node = self.goal while not node is None: stck.push(node.board) node = node.prev return stck
def test_push(): """Test stack push method.""" from stack import Stack from stack import Node stack = Stack() stack.push(data[0]) assert isinstance(stack.head, Node)
def test_pop_2(): our_list = ["first", "second", "third", "fourth"] our_stack = Stack(our_list) assert our_stack.pop() == "fourth" assert our_stack.pop() == "third" assert our_stack.pop() == "second" assert our_stack.pop() == "first"
def __init__(self): ''' Initialize Queue ''' self.stack1 = Stack() self.stack2 = Stack()
def test_count(COUNT_LIST, count): """Test to see if stack count is correct.""" from stack import Stack s = Stack() for i in COUNT_LIST: s.push(i) assert s.size() == count
def test_push(): my_stack = Stack([1, 2, 3]) my_stack.push(4) # assert my_stack.container.display() == (4, 3, 2, 1) assert my_stack.pop() == 4 # check to make sure new stack wasn't initialized assert my_stack.pop() == 3
def test_empty(): """Test case where an empty list is pushed to stack.""" from stack import Stack stacky = Stack() stacky.push([]) with pytest.raises(IndexError): stacky.pop().get_data()
class VisitOrder: stack = None level = 0 node_list = [] def __init__( self ): self.stack = Stack() def make_stack( self ): while self.stack.length() > 0: print "self.stack.length() ==> " + str( self.stack.length() ) print "Pop the stack ---> " + str( self.stack.pop().value ) def get_node( self, node_id ): for n in self.node_list: #print 'get_node ' + str( n.id ) if n.id == node_id: return n return None def build_tree( self, node ): self.level = self.level + 1 print "in build_tree level : " + str( self.level ) while len( node.value ) > 0: node.left = self.stack.pop() build_tree( node.left ) while len( node.value ) > 0: node.right = self.stack.pop() build_tree( node.right )
class StackAllTestCase(unittest.TestCase): """Comprehensive tests of (non-empty) Stack.""" def setUp(self): """Set up an empty stack.""" self.stack = Stack() def tearDown(self): """Clean up.""" self.stack = None def testAll(self): """Test adding and removeping multiple elements.""" for item in range(20): self.stack.add(item) assert not self.stack.is_empty(), \ 'is_empty() returned True on a non-empty Stack!' expect = 19 while not self.stack.is_empty(): assert self.stack.remove() == expect, \ ('Something wrong on top of the Stack! Expected ' + str(expect) + '.') expect -= 1
def __init__(self): ''' Initialize the queue with two stacks -- an incoming and outgoing stack. ''' self.incoming_stack = Stack() self.outgoing_stack = Stack()
def test_push_pop(input_list): from stack import Stack new_stack = Stack() for item in input_list: new_stack.push(item) for item in reversed(input_list): assert new_stack.pop() == item
def stack_sort(s): def find_max(s): t = Stack() m = None while s.size > 0: v = s.pop() t.push(v) if not m or v > m: m = v while t.size > 0: v = t.pop() if v != m: s.push(v) return m sort = Stack() while s.size > 0: m = find_max(s) sort.push(m) while sort.size > 0: s.push(sort.pop()) return s
def heightStack(height, nameStr): h = Stack(nameStr) while height != 0: h.push(height) height -= 1 return h
def converter(exp, fix="post"): """takes simple infix expression and converts to prefix or postfix""" tokens = list(exp) open_paren, close_paren = "(", ")" if fix not in ["pre", "post"]: raise ValueError("Must specify conversion as either 'pre' or 'post'") if fix == "pre": tokens.reverse() open_paren, close_paren = ")", "(" s = Stack() result = '' for t in tokens: if t == open_paren: pass elif t in ["*", "+", "-", "/"]: s.push(t) elif t == close_paren and not s.is_empty(): result += s.pop() else: result += t if fix == "pre": return result[::-1] return result
class Transactor: def __init__(self): self.stack = Stack() self.transaction_queue = [] def start_transaction(self): """ (Transactor) -> NoneType Starts an "undo"-able set of events. """ self.transaction_queue = [] def end_transaction(self): """ (Transactor) -> NoneType Ends the current set of events. """ self.stack.push(self.transaction_queue) self.transaction_queue = [] def add_action(self, action): """ (Transactor, function) -> NoneType Adds an action onto the list of transactions. """ self.transaction_queue.append(action) def undo(self): """ (Transactor) -> NoneType Undoes the last set of transactions. Returns true on success, or false on failure (indicating there were no more transactions to undo). Can throw a stack.EmptyStackError, which should be handled! """ for cmd in reversed(self.stack.pop()): cmd()
def revString(string): s = Stack() for c in string: s.push(c) while not s.isEmpty(): print(s.pop(), end = '')
class MyQueue: def __init__(self): self.stack_in = Stack() self.stack_out = Stack() def enqueue(self, item): if not self.stack_in.is_empty(): self.empty_stack(self.stack_in, self.stack_out) self.stack_in.push(item) def dequeue(self): if not self.stack_out.is_empty(): self.empty_stack(self.stack_out, self.stack_in) return self.stack_in.pop() def empty_stack(self, stack1, stack2): ''' Empty stack1 into stack2 ''' while not stack1.is_empty(): stack2.push(stack1.pop()) def print_mq(self): self.empty_stack(self.stack_in, self.stack_out) print self.stack_out
def test_push(): stack= Stack() stack.push(0) assert stack._lst.head.datum==0 stack.push('dookie') assert stack._lst.head.datum=='dookie'
def test_start(): """Test that empty stack has no head.""" from stack import Stack stacky = Stack() try: stacky.pop().get_data() except IndexError: assert True
def test_size(self): test_stack = Stack() test_stack.push("Woooooo") test_stack.push("Boooooo") test_stack.push("UNITTTTESSSSTS") self.assertEquals(3, test_stack.size)
def dec2bin(num): s = Stack() while num > 0: s.push(num % 2) num = num //2 while not s.isEmpty(): print(s.pop(), end = '')
def test_simple_reverse(self): stack = Stack() stack.push(1) stack.push(2) reverse(stack) self.assertEqual(stack.pop(), 1) self.assertEqual(stack.pop(), 2) self.assertTrue(stack.is_empty())
def rev_string(string): s = Stack() rev_s = ' ' for char in string : s.push(char) while not s.isEmpty(): rev_s = rev_s + s.pop() return rev_s
def test_reverse_many(self): stack = Stack() for i in range(100): stack.push(i) reverse(stack) for i in range(100): self.assertEqual(stack.pop(), i) self.assertTrue(stack.is_empty())
def rev_string(my_str): s = Stack() for mental in my_str: s.push(mental) jogi = '' for gh in range(len(s.items)): jogi = jogi + s.pop() return jogi
def revstring(mystr): myStack = Stack() for ch in mystr: myStack.push(ch) revstr = '' while not myStack.isEmpty(): revstr = revstr + myStack.pop() return revstr
def codeeval_input2(): stack = Stack() node1 = Node(10, None) node2 = Node(-2, node1) node3 = Node(3, node2) node4 = Node(4, node3) stack.head = node4 return stack
def test_history_depth_limit(self): s = Stack() [s.push('X') for n in range(Stack.DEPTH_HISTORY * 2)] self.assertEqual(len(s.depth_history()), Stack.DEPTH_HISTORY) self.assertEqual(len(s.depth_history(Stack.DEPTH_HISTORY * 2)), Stack.DEPTH_HISTORY) self.assertEqual(len(s.depth_history(17)), 17)
def path(self, method="BFS"): ''' Find path for the maze. The default method is Breadth First Search (BFS). The other method is Depth First Search (DFS). Also created is a matrix, _pmatrix, to represent the path. With the same dimension as _matrix, that of the maze, the matrix element is set to P(=2) for the path, otherwise remains 0.''' print(f"Path - {method}") # Initialize the path matrix, _pmatrix self._pmatrix = np.zeros((self.nrow * 2 + 1, self.nrow * 2 + 1), dtype=int) # Availabe methods for solving for path methods = {"BFS": self._bfs, "DFS": self._dfs} # Using _edgeTo from BFS or DFS, from the last room, i.e. room number nmaze-1, # the path from 0 to nmaze-1 can be obtained. i = self.nmaze - 1 methods[method]() s = Stack() while self._edgeTo[i] is not i: s.push(i) i = self._edgeTo[i] s.push(i) self._path = [s.pop() for i in range(len(s))] # With the path from room 0 to room nmaze-1 obtained, set those correspond to rooms # and passages in _pmatrix to be 2; others remain 0. self._pmatrix[0, 1] = self._pmatrix[self.nrow * 2, self.nrow * 2 - 1] = P for i in range(len(self._path) - 1): ir = (self._path[i] // self.nrow * 2 + 1) ic = (self._path[i] % self.nrow * 2 + 1) self._pmatrix[ir, ic] = P step = self._path[i + 1] - self._path[i] if step in (1, -1): ic += step self._pmatrix[ir, ic] = P else: ir += step // self.nrow self._pmatrix[ir, ic] = P ir = (self._path[len(self._path) - 1] // self.nrow * 2 + 1) ic = (self._path[len(self._path) - 1] % self.nrow * 2 + 1) self._pmatrix[ir, ic] = P # Print path in ASCII format for i in range(1, 2 * self.nrow, 2): for j in range(1, 2 * self.nrow, 2): if self._pmatrix[i, j] == P: print("x", end="") else: print(" ", end="") print() print() # Plot path in graphics self.plotMaze(f"Maze: {self.nrow} x {self.nrow}\nSolution: " + method, self._matrix, solution=True) return self._path, [i for i in self._visited]
#define a function to retrieve our infix string from the command line. Argparse is awesome, so why done we use it?? def parse_args(): parser = argparse.ArgumentParser() parser.add_argument('-s', action='store',dest='infix_string',help="use infix_prefix.py -s 'A * (B+ C)' ",required=True) return parser.parse_args() #get our arguments in a neat result variable results = parse_args() #lets split our string directly from the results variable split_infix_string = results.infix_string #print 'infix stringzee to be proccessed: ',split_infix_string #test our infix string out #print split_infix_string operatorStack = Stack() operandStack = Stack() for token in split_infix_string: #print "First Token thru: ",token,"\n" if token.isalpha() or token in ['+','-','/','*',')','(']: if token.isalpha(): operandStack.push(token) #print 'Pushing Operand:',token,"\n" elif token == '(' or operatorStack.is_empty() or (prec[token] >= prec[operatorStack.peek()]): #print 'pushing token: ', token, "\n" operatorStack.push(token) elif token == ')': #print 'right paren found' while(operatorStack.peek() != '('):
def test_has_method(method): """Test that queue has all the correct methods.""" from stack import Stack assert hasattr(Stack(), method)
def segment(query): # get the request from terminal, split it and put parts into a list flag = 0 query = pre_processing(query) # print(query) request = query.split() # result of semantic: a operation sequence request = detect_input_lists(request) seq = [] # stack used to analysis stk = Stack() for w in request: # print(w) # operator in bracket would be pushed until meet a ")" if w in bracket: if w in methods: flag = 1 stk.push(w) else: if stk.peek() in methods and w == "(" and flag == 1: flag = 0 continue stk.push(w) # if w is a number (could be int or float) else: flag = 0 if is_number(w): seq.append(float(w)) # compare the priority of w and operator on the top of the stack elif type(w) is list: seq.append(w) elif w in priority: top = stk.peek() # if the priority of w is not bigger than the top # pop the top into result until priority of w is bigger than top while top is not None and priority[w] <= priority[top]: seq.append(stk.pop()) top = stk.peek() stk.push(w) # meet a ")", continue popping until meet operator in bracket elif w == ")": top = stk.peek() while top is not None and top not in bracket: # print(top) seq.append(stk.pop()) top = stk.peek() # assert(stk.peek() != "(") # ignore "(" if top != "(": seq.append(stk.pop()) # append the external name else: seq.append(w) # request end # append remain operator while stk.peek() is not None: # ignore "(" if stk.peek() != "(": seq.append(stk.pop()) else: stk.pop() # print(seq) return seq
'''Zadanie1 Napisz funkcję w języku Python (lub wykorzystaj funkcję z poprzednich zajęć), który w oparciu o stos oblicza wartość wyrażenia zapisanego w notacji postfiksowej. Zakładamy, że korzystamy z 4 klasycznych operacji arytmetycznych +, -, * oraz /. Przykładowo dla danych wejściowych ”20 10 + 75 45 - * ” wynik powinien wynosić 900. Funkcję proszę nazwać Postfix Eval().''' from stack import Stack stos = Stack() def Postfix_Eval(word): tempdig = '' for c in word: if c.isdigit(): tempdig += c elif c in '/*-+': temp = str(stos.pop()) stos.push(eval(str(stos.pop()) + c + temp)) elif c == ' ' and tempdig != '': stos.push(tempdig) tempdig = '' return stos.pop() print(Postfix_Eval('20 10 + 75 45 - *'))
def __init__(self): super().__init__() self.stack1 = Stack() self.stack2 = Stack()
from stack import Stack def reverse_string(stack, input_str): #loop through the string and push contents #char by char onto stack for i in range(len(input_str)): stack.push(input_str[i]) rev_str = "" while not stack.is_empty(): rev_str += stack.pop() return rev_str input_str = "Hello" s = Stack() print(reverse_string(s, input_str))
def setUp(self): """Set up an empty queue. """ self.stack = Stack()
class Queue: def __init__(self): self.first = Stack() self.second = Stack() def empty(self): # if len(self.container): # return False # return True if self.first.empty() and self.second.empty(): return True return False def enqueue(self, data): self.first.push(data) def dequeue(self): if self.empty(): return None if self.second.empty(): while not self.first.empty(): self.second.push(self.first.pop()) return self.second.pop() def peek(self): # return self.container[0] if self.empty(): return None if self.second.empty(): while not self.first.empty(): self.second.push(self.first.pop()) return self.second.peek()
def generatePostfixTokens(expression: List[str], operators: List[str] = []): # Reference: # https://www.geeksforgeeks.org/stack-set-2-infix-to-postfix/ precidence = {"^": 3, "*": 2, "/": 2, "+": 1, "-": 1, "=": 0} stack = Stack() postfix = [] for token in expression: if token not in ["^", "*", "/", "+", "-", "(", ")", '='] + operators: # If it's an operand, add it into the postfix postfix.append(token) elif token == '(': # If it's an opening parenthesis, add it to the stack stack.push('(') elif token == ')': # If it's a closing parenthesis, add operators to postfix # Until a '(' is found or the stack is empty while not stack.isEmpty() and stack.peek() != '(': postfix.append(stack.pop()) # Remove closing parenthesis from stack if stack.peek() == '(': stack.pop() else: # It's an operator # If the current token's 'precidence' (Eg, * is evaluated before +) # is less than or equal to the one in the stack, while not stack.isEmpty( ) and stack.peek() != '(' and precidence.get( token, 1) <= precidence.get(stack.peek(), 1): postfix.append(stack.pop()) stack.push(token) while not stack.isEmpty(): postfix.append(stack.pop()) return postfix
from linked_list import Node from stack import Stack ## Stack Test Cases ## Set up seme Elements node1 = Node(1) node2 = Node(2) node3 = Node(3) node4 = Node(4) # Start setting up a Stack stack = Stack(node1) # Test stack functionality stack.push(node2) stack.push(node3) print(stack.pop().value) print(stack.pop().value) print(stack.pop().value) print(stack.pop()) stack.push(node4) print(stack.pop().value)
def push(self, item): if len(self.stacks[self.current_stack]) >= self.capacity: self.stacks.append(Stack()) self.current_stack += 1 self.stacks[self.current_stack].push(item)
def __init__(self, capacity=3): self.stacks = [Stack()] self.current_stack = 0 self.capacity = capacity
def setUp(self): """Set up an empty stack.""" self.stack = Stack()
def __init__(self, type=DagNode): self._type = type self._nodes = {} self._stack = Stack() self._root = self._type("root") self._stack.push(self._root)
def __init__(self): super(StackMin, self).__init__() self._stack_min = Stack()
from stack import Stack s = Stack() s.push("Hello") s.push("World") s.push('1') s.push('4') print(s.pop()) print(s.pop()) print(s.pop())
#!/usr/bin/env python3 from stack import Stack def str_rev(stack,inp_str): for word in inp_str: stack.push(word) rev_str = "" while not stack.is_empty(): rev_str+=stack.pop() return rev_str stack = Stack() inp_str = input("Enter your str: ") print(str_rev(stack,inp_str))
class Dag: def __init__(self, type=DagNode): self._type = type self._nodes = {} self._stack = Stack() self._root = self._type("root") self._stack.push(self._root) def add(self, depth, object): assert depth > 0, 'depth cant be less equal zero' if depth > self.__getDepth() + 1: raise Exception("Wrong depth, stack: ", self.__getDepth(), ", depth: ", depth) depthDifference = self.__getDepth() - depth + 1 for i in range(0, depthDifference): self._stack.pop() assert self._stack.empty() == False, 'stack cant be empty' header = self.__getOrCreate(object) if self.__areConnected(self._stack.top(), header) == False: if self.__checkForCycle(self._stack.top(), header) == False: self.__connect(self._stack.top(), header) self._stack.push(header) return header def get(self, object): if object not in self._nodes: raise Exception("object does not exist") return self._nodes[object] def getNodes(self): return self._nodes.values() def getRoot(self): return self._root def deepPrint(self): self._root.deepPrint() def __areConnected(self, node1, node2): return node2 in node1.getChildren() def __connect(self, node1, node2): node1.addChild(node2) node2.addParent(node1) def __getDepth(self): return self._stack.size() - 1 def __getOrCreate(self, object): if object not in self._nodes: self._nodes[object] = self._type(object) return self._nodes[object] def __checkForCycle(self, parent, node): result = self.__checkForCycleImpl(parent, node) node.setColorRecursively(DfsNode.White) return result def __checkForCycleImpl(self, parent, node): if node.getColor() == DfsNode.Black: return False node.setColor(DfsNode.Black) if parent == node: return True for child in node.getChildren(): if self.__checkForCycleImpl(parent, child) == True: return True return False
def infix_parts_to_postfix(terms): result = [] stack = Stack() for elem in terms: if isinstance(elem, int): result.append(elem) elif elem == '(': stack.push(elem) elif elem == ')': while not stack.is_empty(): top = stack.pop() if top != '(': result.append(top) else: break elif not stack or PRECEDENCE[elem] > PRECEDENCE[stack.top()]: stack.push(elem) else: while stack and PRECEDENCE[elem] <= PRECEDENCE[stack.top()]: result.append(stack.pop()) stack.push(elem) while stack: result.append(stack.pop()) return result
from stack import Stack def reverse_string(stack, str_in): s = Stack() for i in range(len(str_in)): s.push(str_in[i]) rev_str = "" while not s.is_empty(): rev_str += s.pop() return rev_str a = Stack() str_in = "Hello" print(reverse_string(a, str_in))
from stack import Stack if __name__ == '__main__': s = Stack(3) s.push(5) s.push(8) s.push(9) s.push(10) s.pop() s.pop() print(s)
def test_init_with_list(self): s = Stack(['A', 'B', 'C']) assert s.peek() == 'C' assert s.length() == 3 assert s.is_empty() is False
def test_length(self): s = Stack() assert s.length() == 0 s.push('A') assert s.length() == 1 s.push('B') assert s.length() == 2 s.pop() assert s.length() == 1 s.pop() assert s.length() == 0
from stack import Stack print("\nLet's play Towers of Hanoi!!") # Create the Stacks stacks = [] left_stack = Stack("Left") middle_stack = Stack("Middle") right_stack = Stack("Right") stacks.extend([left_stack, middle_stack, right_stack]) # Set up the Game num_disks = int(input("\nHow many disks do you want ot play with?\n")) while num_disks < 3: num_disks = int(input("Enter a number greater than or equal to 3\n")) for i in range(num_disks): left_stack.push(i) num_optimal_moves = 2**num_disks - 1 print("\nThe fastest you can solve this game is in {} moves".format( num_optimal_moves)) # Get User Input def get_input(): choices = [i.get_name()[0] for i in stacks] while True: for i in range(len(stacks)):
def zig_zag_traverse(node): if node is None: return current_stack = Stack() next_stack = Stack() left_to_right = True current_stack.push(node) while not current_stack.is_empty(): temp = current_stack.pop().data #print ("inslide node {}".format(temp.data)) if temp: print(temp.data) if left_to_right: if temp.left: next_stack.push(temp.left) if temp.right: next_stack.push(temp.right) else: if temp.right: next_stack.push(temp.right) if temp.left: next_stack.push(temp.left) if current_stack.is_empty(): left_to_right = not left_to_right current_stack, next_stack = next_stack, current_stack return
def postEval(expression, assignments): digits = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'] operators = ['+', '*', '-'] variables = assignments.keys() s = Stack() for c in expression: if c == ' ': continue if c in digits: s.push(c) continue if c in variables: s.push(assignment[c]) continue if c in operators: try: op1 = s.pop() except EmptyStack as errore: raise BadExpression try: op2 = s.pop() except EmptyStack as errore: raise BadExpression if c == '-': s.push(int(op2) - int(op1)) if c == '*': s.push(int(op1) * int(op2)) if c == '+': s.push(int(op1) + int(op2)) continue raise BadExpression val = s.pop() if not s: return val else: raise BadExpression return s.pop()
def stock_span(array): result = [] stack = Stack() for index, item in enumerate(array): # If STack is empty d = {"key": index, "value": item} if (stack.is_empty()): result.append(-1) # If top is greater then item elif (stack.peek().get('value') > item): result.append(stack.peek().get('key')) # if top is less than or equal to item elif (stack.peek().get('value') <= item): while (stack.peek().get('value') <= item): popped = stack.pop() if (stack.peek() is None): break if (stack.is_empty()): result.append(-1) else: result.append(stack.peek().get('key')) stack.push(d) return [ind - val for ind, val in enumerate(result)]
def setUp(self): """Set up a queue with a single element. """ self.stack = Stack() self.stack.add('a')
def __init__(self): self.first = Stack() self.second = Stack()