def dectobin(n): s=Stack() while (n>0): m=n%2 s.push(m) n=int(n/2) return s
def revrse(expr): revsd=[] stck=Stack() for each in expr: stck.push(each) while stck.isEmpty() is not True: revsd.append(stck.pop()) print ''.join(revsd)
def convertStack(self,stack,newBase,oldBase): revStack = Stack() while stack.length() != 0: revStack.push(stack.pop()) while revStack.length() != 0: stack.push(Operation.__convertFromDecimal( Operation.__convertToDecimal(revStack.pop(),oldBase),newBase)) del revStack
def __init__(self,numMarbles): self.resv = Queue() self.oneMin = Stack() self.fiveMin = Stack() self.hour = Stack() assert numMarbles >= 27 for i in range(numMarbles): self.resv.enqueue(i)
def buildParseTree(exp_string): exp_list = exp_string.split() parent_stack = Stack() root = BinaryTree(None) current_node = root for token in exp_list: if token == "(": current_node.insertLeft(None) parent_stack.push(current_node) current_node = current_node.getLeftChild() elif token in "+-*/": current_node.setRootVal(token) parent_stack.push(current_node) current_node.insertRight(None) current_node = current_node.getRightChild() elif token == ")": if parent_stack.size() > 0: parent_node = parent_stack.pop() current_node = parent_node else: current_node.setRootVal(float(token)) if parent_stack.size() > 0: parent_node = parent_stack.pop() current_node = parent_node return root
def buildParseTree(fpexp): fplist = fpexp.split()#將str以sep分割成子字串,回傳儲存子字串的串列 pStack = Stack() eTree = BinaryTree('') pStack.push(eTree) currentTree = eTree for i in fplist: if i == '(': currentTree.insertLeft('') pStack.push(currentTree) currentTree = currentTree.getLeftChild() elif i not in ['+', '-', '*', '/', ')']: currentTree.setRootVal(int(i)) parent = pStack.pop() currentTree = parent elif i in ['+', '-', '*', '/']: currentTree.setRootVal(i) currentTree.insertRight('') pStack.push(currentTree) currentTree = currentTree.getRightChild() elif i == ')': currentTree = pStack.pop() else: raise ValueError return eTree
def postEval(symbolString): """Given a postfix expression, evaluate it""" if symbolString == None: return None tokens = symbolString.split() stack = Stack() for token in tokens: # Is the token an integer? if token.isdigit(): stack.push(int(token)) # otherwise, it must be an operator elif stack.__len__() <= 1: print("Ill-formed expression") return None else: arg1 = stack.pop() arg2 = stack.pop() # Evaluate operator expressions (handles exceptions) val = applyOp(token, arg1, arg2) stack.push(val) if not stack.__len__() == 1: print("Ill-formed expression") return None return stack.pop()
class Queue_from_Stacks(object): def __init__(self): self.in_stack = Stack() self.out_stack = Stack() self.length = 0 def is_empty(self): return self.length <= 0 def enqueue(self, element): self.in_stack.push(element) self.length += 1 def dequeue(self): if(self.out_stack.is_empty()): while (not(self.in_stack.is_empty())): self.out_stack.push(self.in_stack.pop()) if (not(self.out_stack.is_empty())): self.length -= 1 return self.out_stack.pop() def __repr__(self): return "IN: " + str(self.in_stack) + "\nOUT: " + str(self.out_stack)
def dec_to_base(dec, base): digits = "0123456789ABCDEF" s = Stack() while dec > 0: s.push(dec % base) dec = dec / base yeni = "" while not s.isEmpty(): yeni = yeni + digits[s.pop()] return yeni
def to_binary_num(decimal): s = Stack() while decimal > 0: rem = decimal % 2 s.push(rem) decimal /= 2 ans_string = "" while not s.is_empty(): ans_string += str(s.pop()) return ans_string
def decTo(self): digits = "0123456789ABCDEF" remstack = Stack() while self.val > 0: rem = self.val % self.base remstack.push(rem) self.val = self.val / self.base newOne = "" while not remstack.isEmpty(): newOne = newOne + digits[remstack.pop()] return newOne
class MaxStack: def __init__(self): self.base = Stack() self.max = Stack() def push(self, item): if item >= self.max.peek(): self.max.push(item) self.base.push(item) def pop(self): val = self.base.pop() if (val == self.max.peek()): self.max.pop() return val def getmax(self): return self.max.peek()
def bracketChecker(user_input): s = Stack() for c in user_input: if c == ("(" or "[" or "{"): s.push(c) elif c == (")" or "]" or "}"): if s.isEmpty(): return False else: top = s.pop() if not matches(top, c): return False else: pass return True
def balanced(expr): stck=Stack() for each in expr: if typeOfPara(each) is "lpar1" or typeOfPara(each) is "lpar2" or typeOfPara(each) is "lpar3": typ=typeOfPara(each) stck.push(typ) elif typeOfPara(each) is "rpar1" or typeOfPara(each) is "rpar2" or typeOfPara(each) is "rpar3": typ=typeOfPara(each) spop=stck.pop() if match(spop)==typ: continue else: break if stck.isEmpty() is not True: print "Unbalanced Paranthesis" else: print "Balanced Paranthesis"
def run_loop(params): external = params print 'external: ', external cort_neurons = [MLEF.MorrisLecarElectricField(0.2, p=0.2) for e in range(num_cort_neurons)] #motor_units = ST.generate_linear_spectrum_motor_units(10, 20e-04, 10e-03, 1.0, 11.0, 5.0, 10.0, 7.0, 14.0) motor_units = ST.generate_linear_spectrum_motor_units(10, 20e-04, 200e-03, 1.0, 11.0, 5.0, 50.0, 7.0, 70.0) stack = ST.Stack(run_time, cort_neurons, motor_units, cortical_soma_input=lambda t: soma_current[t], cortical_ext_input=lambda t: external) stack.run() stack.muscle.get_total_force() return [e.total_force for e in stack.motor_units]
def __init__(self, Id, Location, MoviePlaying, StartTime): """ Creates a new instance of a showtime. """ # Pre: # Id must be a valid and unique identifier, the location must be an existing at the theater, the movie must be known to the theater and the start time must correspond to one of the theater's time slots. self.number_of_free_seats_value = 0 self.tickets = Stack() self.id = Id self.location = Location self.movie_playing = MoviePlaying self.start_time = StartTime self.number_of_free_seats = Location.number_of_seats
def __fromDecimal(self, base): number = str(self.getDeciValue()) negative = True if "-" in number < 0 else False if negative: number = number[1:] remainders = Stack() separated_num = self.__separateFloat(str(float(number))) integer = separated_num[0] fraction = separated_num[1] number = int(integer) while number > 0: remainder = number % base remainders.push(int(remainder)) number = number // base integer = "" if not remainders.is_empty() else "0" while not remainders.is_empty(): try: integer += Number.__DIGITS[remainders.pop()] except IndexError as BaseError: raise Exception( "Base outside range of representable digits.") from BaseError fraction = "0." + fraction fraction = self.__convertDecimalFraction(fraction, base) output = integer + fraction if negative: output = "-" + output self.__setValue(output)
def parChecker(symbolString): s=Stack() balanced = True # default index =0 while index < len(symbolString) and balanced: symbol=symbolString[index] # if (,{,[ push onto stack if symbol in "({[": s.push(symbol) else: # if stack is empty, imbalance if s.isEmpty(): balanced = False else: top=s.pop() if not matches(top,symbol): balanced = False index = index+1 # balanced and no ( present if balanced and s.isEmpty(): return True # otherwise unbalanced ( present else: return False
def redeem_ticket(self, Theater, Customer): """ Have one person redeem their ticket and enter the showtime. Note that a user who reserved more than one ticket must enter the showtime multiple times, once per ticket. """ # Pre: # The customer must be a user who has an unredeemed ticket for this showtime. # The theater must be the theater containing this showtime. # Post: # If the customer does not have an unredeemed ticket for this showtime, this method does nothing. # If, on the other hand, the user does, their ticket is redeemed, and their absence will no longer delay the showtime. # If the last ticket was redeemed, the showtime begins, and is be removed from the theater's showtime list. if self.has_ticket(Customer): tempStorage = Stack() while not self.tickets.is_empty: item = self.tickets.pop() if item.customer == Customer: break else: tempStorage.push(item) while not tempStorage.is_empty: self.tickets.push(tempStorage.pop()) if self.tickets.is_empty: Theater.showtimes.remove(self.id)
def testPop(self): stack = Stack() stack.push(0) stack.push(5) stack.push(2) item = stack.pop() self.assertEquals(item, 2) self.assertEquals(stack.data, [0, 5])
def DFS_iterative(Graph, node, nodes_list): global time stack = Stack() stack.push(node) while not stack.isEmpty(): nodes_list[node].explore() nodes_list[node].set_leader(source_node) node = stack.peek() if len(Graph[node]) != 0: linked_node = Graph[node].pop() if nodes_list[linked_node].get_not_explored(): stack.push(linked_node) else: time += 1 nodes_list[stack.pop()].set_time(time)
def SortStack(mystack): HelpStack = Stack() while not mystack.isEmpty(): MaxValue = mystack.pop() while not HelpStack.isEmpty() and HelpStack.peek() > MaxValue: mystack.push(HelpStack.pop()) HelpStack.push(MaxValue) return HelpStack
def TestPop(self): '''post: removes and returns the top element of the stack''' stack = Stack() stack.push(5) stack.pop(5) self.assertEqual(stack.items[-1], 0)
def print_list_reversely(p): s = Stack() li = [] while p: s.push(p.elem) p = p.next while not s.is_empty(): li.append(s.pop()) print(li)
def bin(n): res = Stack() while n != 0: res.push(n % 2) n = n // 2 ans = "" while not res.isEmpty(): ans += str(res.pop()) return ans
def parChecker(string): s = Stack() balanced = True idx = 0 while idx < len(string) and balanced: symbol = string[idx] if symbol in '([{': s.push(symbol) else: if s.isEmpty(): return False elif not matches(s.peek(), symbol): return False s.pop() idx += 1 if s.isEmpty() and balanced: return True else: return False
def convert_infix_to_postfix(infix): if infix is None: return None prec_map = get_precedence_map() #print prec_map opstack = Stack.Stack() result_postfix = [] for item in infix: print "--------------------------item: "+str(item) # if operand just add it to result if item in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or item in "0123456789": print "appending: "+str(item) result_postfix.append(item) opstack.print_stack() # if "(" just push it to stack elif item == "(": opstack.push(item) opstack.print_stack() # add to result upto open brace elif item == ")": top_elem = opstack.pop() while top_elem.get_data() != "(" and opstack.size > 0: print "appending: "+str(top_elem.get_data()) result_postfix.append(top_elem.get_data()) top_elem = opstack.pop() opstack.print_stack() #result_postfix.append(top_elem) # no need to append paranthesis in result. else: # should be an operator while opstack.size > 0 and prec_map[opstack.peek()] >= prec_map[item]: temp = opstack.pop() print "appending: "+str(temp.get_data()) result_postfix.append(temp.get_data()) opstack.push(item) # after popping existing operator , push the current one. (or) without popping just push. based on the precedence check. opstack.print_stack() #print result_postfix while opstack.size != 0: result_postfix.append(opstack.pop().get_data()) return result_postfix
def main(): # initialize a stack mystack = Stack() mystack.push(3) mystack.push(1) mystack.push(5) mystack.push(2) mystack.push(4) sorted_stack = SortStack(mystack) while not sorted_stack.isEmpty(): print sorted_stack.pop()
class QueueWith2Stacks: def __init__(self): self.stack1 = Stack() self.stack2 = Stack() self.size = 0 def add(self, item): self.stack1.push(item) self.size += 1 def remove(self): for i in range(self.size): value = self.stack1.pop() self.stack2.push(value) firstElem = self.stack2.pop() self.size -= 1 for i in range(self.size): value = self.stack2.pop() self.stack1.push(value) return firstElem
class Automata: def __init__(self): self.estados = Stack() #Este metodo se encarga de leer el fichero que incluye los estados en texto plano def leerArchivo(self): archivo = open("jugadas/5.dat", "r") archivo.readline() #elimino el salto de linea al final linea = archivo.readline().rstrip('\n') #elimino el punto al final del texto y retorno dicho texto return linea.rstrip('.') #Este metodo es el que crea la pila y agrega los objetos, hace un match entre los caracteres y los numeros def crearPilaAutomata(self): guiones = self.leerArchivo() #guardo en la variable estados cada uno de los guiones separados por coma estadossinMatch = [] estadossinMatch = guiones.split(",") for estado in estadossinMatch: match = re.match(r"([a-z]+)([0-9]+)",estado, re.I) if match: items = match.groups() escenario = items[0] numeros = items[1] cad_numero = str(numeros) base = cad_numero[0] try: jugador = int(cad_numero[1]) except: jugador = 0 self.estados.push(Estado(escenario,base,jugador))
def test_delete(self): """! Testing of delete method """ Stack1 = Stack.Stack() Stack1.push(1) Stack1.push(2) Stack1.push(3) Stack1.pop() self.assertEqual(2, Stack1.size()) self.assertEqual(1, Stack1.getBody()[0]) self.assertEqual(2, Stack1.getBody()[1]) Stack2 = Stack.Stack() Stack2.push("1") Stack2.push("2") Stack2.push("3") Stack2.push("4") Stack2.push("5") Stack2.pop() Stack2.pop() Stack2.pop() self.assertEqual(2, Stack2.size()) self.assertEqual("1", Stack2.getBody()[0]) self.assertEqual("2", Stack2.getBody()[1]) Stack3 = Stack.Stack() Stack3.push(1.86) Stack3.push(2.15) Stack3.push(2.34) Stack3.push(5.76) Stack3.push(9.81) Stack3.pop() self.assertEqual(4, Stack3.size()) self.assertEqual(1.86, Stack3.getBody()[0]) self.assertEqual(2.15, Stack3.getBody()[1]) self.assertEqual(2.34, Stack3.getBody()[2]) self.assertEqual(5.76, Stack3.getBody()[3])
def inorder_iter(tree): current = tree s = st.Stack() is_done = False while not is_done: if current: s.push(current) current = current.leftChild else: if not s.is_empty(): current = s.pop() print(current.key) current = current.rightChild else: is_done = True
def __repr__(self): m = self.m if m == 1 or m == 0: raise Exception("Si le facteur de compression est de 0 ou de 1, il est impossible de créer un arbre fini.") stack = Stack() current = self.__urn stack.push(current) while current.getSize() != 1: #push chaque niveau de l'arbre sur le stack current = current.getCompressed(m) stack.push(current) f = Queue() root = stack.pop().getBallot(0) #initialisation à la racine de l'arbre (taille du premier niveau = 1) tree = Forest(str(root)) f.insert(tree) while not stack.isEmpty(): #tant qu'il y a des niveaux à rajouter level = stack.pop() #niveau à lier au niveau précédent i = 0 toModify = f.size() #nombre de noeuds du niveau précédent while i < toModify: n = f.remove() node = level.getBallot(i*m) n.modifyChild(str(node)) #on ajoute un premier fils f.insert(n.getChild()) #on le mémorise pour modifier son fils par après j=1 n = n.getChild() while (j < m and (i*m)+j < level.getSize()): #on ajoute m-1 frère(s) à ce fils node = level.getBallot(i*m+j) n.modifyBrother(str(node)) #on ajoute un frère f.insert(n.getBrother()) #on le mémorise pour modifier son fils par après n = n.getBrother() #n devient le frère de n afin de lui ajouter un frère à l'itération suivante j+=1 i += 1 tree.niveau(m) return ""
def bracket_balanced_check(s): stack = Stack.Stack() open_list = ['[', '{', '('] close_list = [']', '}', ')'] for i in s: if i in open_list: stack.push(i) elif i in close_list: pos = close_list.index(i) if (len(stack) > 0) and open_list[pos] == stack.peek(): stack.pop() else: return 'Unbalance' if len(stack) == 0: return 'Balanced'
def test_stack_pushpushpop(): stack = Stack.Stack() stack.PUSH(5) assert stack.S == [5] + [None] * 19 assert stack.top == 1 assert stack.STACK_EMPTY == False stack.PUSH(7) assert stack.S == [5, 7] + [None] * 18 assert stack.top == 2 assert stack.STACK_EMPTY == False popped = stack.POP() assert stack.S == [5, 7] + [None] * 18 assert stack.top == 1 assert popped == 7 assert stack.STACK_EMPTY == False
def is_matched(expr): """Return True if delimiters are properly matched. False otherwise""" lefty = "({[" righty = ")}]" s = Stack.ArrayStack() for c in expr: if c in lefty: s.push(c) elif c in righty: if s.is_empty(): return False if righty.index(c) != lefty.index(s.pop()): return False return s.is_empty()
def test_pop(self) -> None: """Test the pop function of the stack datastructures """ stack = Stack() stack.push(2) stack.push(3) popped_item = stack.pop() assert (popped_item == 3) and (stack.to_list() == [2])
def path_profiling(adjlist_dict): for key in adjlist_dict: route_stack = Stack.Stack() visited_list = [] paths = [] route_stack.push(key) visited_list.append(key) while not route_stack.is_empty(): current = route_stack.top() #Get the unvisited neighbours for observation neighbours = [] for neighbour in adjlist_dict[current][1]: if neighbour not in visited_list: neighbours.append(neighbour) if len(neighbours) == 0: print( route_stack.my_array) #paths.append(route_stack.my_array) route_stack.pop() # else: route_stack.push(neighbours[0]) visited_list.append(neighbours[0]) # # #Deployment of mac addresses from a path # for mac in mac_addresses: # num_neigh = 5 # current_ap = 'ap1' # while num_neigh > 0: # adjlist_dict[current_ap][0].append(mac) # num_neigh = len(adjlist_dict[current_ap][1]) # if num_neigh > 0: # choice = random.randrange(0, num_neigh, 1) # current_ap = adjlist_dict[current_ap][1][choice] # # keys = adjlist_dict.keys() # for key in keys: # print(key, adjlist_dict[key][0]) # d = timedelta() # for i in range(1000): # print(d.microseconds)
def DepthFirstSearch(graph, startingNodeData): searchStack: Stack = Stack() seen: set = set([]) #visited elements searchStack.push(startingNodeData) while searchStack.isEmpty() == False: currentNodeData = searchStack.pop() if currentNodeData not in seen: seen.add(currentNodeData) print(currentNodeData) for neighbor in graph[currentNodeData]: if neighbor not in seen: searchStack.push(neighbor)
def move_onto(linked, a, b, n): move_over(linked, a, b, n) stack = Stack(n) for item in linked: while item.size() != 0: stack.push(item.pop()) if stack.peek() == a: while True: x = item.pop() if x == b: stack.push(x) break linked.get(x).push(x) sum_stacks(item, stack)
def createGraph(convexHull, pointData): g = igraph.Graph() coords = [] # Creates an initial list for the coordinates to be appended into edgeList =[] # Creates an initial list for the vertex indexes to be appended into so the vertices join up i=1 # Create an initial index while convexHull.isEmpty() is not True: # Code keeps looping until the convex hull has no more points to plot g.add_vertex(str(i)) # Vertex index is just the i counter -> Can't be a stop name because JSON doesn't have # this information coords.append(convexHull.peek()) # Add the coordinates to the coordinates list convexHull.pop() if str(i) != "1": # At i=1 there is not two edges to append to the edge list if int(convexHull.size()) != 0: # The last point needs to append itself and the previous point as well # as the initial point edgeList.append((str(i), str(i-1))) else: # Last Point edgeList.append((str(i), str(i-1))) edgeList.append((str(i), "1")) else: pass i += 1 points = Stack() # Create a stack for the point data to be added into for point in pointData: points.push(point) while points.isEmpty() is not True: g.add_vertex(str(i)) # Adds all the points (The ones in the convex hull are added again, but this does not # affect the graph produced) latitude = points.peek()[0] # Create lat and long variables in order to append them to the coordinate list longitude = points.peek()[1] coords.append((float(latitude), float(longitude))) # Float errors if they aren't converted to variables first points.pop() # Remove the point g.add_edges(edgeList) # Uses the edge list to create the edges visual_style = {} visual_style["layout"] = coords # layout takes a 2d matrix of coordinates and uses them # to position the vertexes. bbox of 2000,2000 appears to be a # suitable size visual_style['bbox'] = (2000,2000) igraph.plot(g, **visual_style)
def isPalindrome_Stacks(inp): i = 0 stack = Stack.Stack() while inp[i] != "X": stack.push(inp[i]) i = i + 1 i = i + 1 #stack.print_stack() while i < len(inp): if stack.size == 0 or stack.pop().get_data() != inp[i]: return -1 i = i + 1 return 1
def postfix_eval(postfix_expr): token_list = postfix_expr.split() operand_stack = Stack() for token in token_list: if token in "0123456789": operand_stack.push(int(token)) else: operand1 = operand_stack.pop() operand2 = operand_stack.pop() result = do_math(operand1, operand2, token) operand_stack.push(result) return operand_stack.pop()
def __init__( self, master, title=__TITLE, base=__BASE) : self.__base = base #INITIALIZE THE STACK self.__stack = Stack() #Initialise the Operation class self.__operation = Operation(self.__stack) # Initialise main calculator window. Tk.__init__( self, master ) # Set title. self.title( title ) #Set not resizable self.resizable(0,0) # Save @master@. Not used... self.__master = master # Finish rest of initialisation. self.__initialise( base=base)
def base_converter(dec_number, base): digits = "0123456789ABCDEF" rem_stack = Stack() while dec_number > 0: rem = dec_number % base rem_stack.push(rem) dec_number = dec_number // base new_string = "" while not rem_stack.is_empty(): new_string = new_string + digits[rem_stack.pop()] return new_string
def divideBybase(decnumber,base): digits="0123456789ABCDEF" remstack=Stack() while decnumber>0: rem =decnumber%base remstack.push(rem) decnumber=decnumber//base binstring="" while not remstack.isEmpty(): binstring=binstring+digits[remstack.pop()] return binstring
def validate(string: str): stack = Stack() for s in string: if s == '(': stack.push('(') elif s == ')': if stack.size == 0: return False stack.pop() return stack.size == 0
def palindromer(s): new_string_stack = Stack() new_string ="" for l in s: new_string_stack.push(l) while (new_string_stack.is_empty() == False): new_string += str(new_string_stack.pop()) return print(new_string)
def CheckMatchinParenthesis2(input): import sys sys.path.append("./mylib") import Stack demoStack = Stack.Stack() for entry in input: if (entry == '('): demoStack.push(entry) elif (entry == ')'): if (demoStack.pop() == -1): return ("unbalanced") exit #Check is stack is empty - more left parenthesis if (demoStack.mysize() == 0): return ("balanced") else: return ("unbalanced")
def testFunctional(self): s = Stack.Stack() self.assertTrue(s.isEmpty()) s.push(4) s.push("dog") self.assertEqual("dog", s.peek()) s.push(True) self.assertEqual(s.size(), 3) self.assertFalse(s.isEmpty()) s.push(8.4) self.assertEqual(8.4, s.pop()) self.assertEqual(True, s.pop()) self.assertEqual(2, s.size())
def evaluate_postfix(postfix): opstack = Stack.Stack() operators = list("+-*/") for item in postfix: if item in "0123456789": opstack.push(item) elif item in operators: operand1 = opstack.pop().get_data() operand2 = opstack.pop().get_data() print "operand1: " + str(operand1) print "operand2: " + str(operand2) opstack.push(doMath( item, operand2, operand1)) # note: operand2 is the earlier element in stack. print opstack.print_stack()
def checkForBalance(stringToCheck): paraStack = Stack.Stack() for item in stringToCheck: if item in "({[": paraStack.push(item) else: if paraStack.isEmpty(): return False else: top = paraStack.pop() if not matches(top, item): return False if paraStack.isEmpty(): return True else: return False
def test_stack_pushpoppop(): with pytest.raises(Stack.Underflow): stack = Stack.Stack() stack.PUSH(5) assert stack.S == [5] + [None] * 19 assert stack.top == 1 assert stack.STACK_EMPTY == False popped = stack.POP() assert stack.S == [5] + [None] * 19 assert stack.top == 0 assert popped == 5 assert stack.STACK_EMPTY == True popped = stack.POP() assert stack.S == [5] + [None] * 19 assert stack.top == 0 assert popped == None assert stack.STACK_EMPTY == True
def postfixEval(postfixExpr): """Evaluate the given postfix expression""" operandStack = Stack.Stack() tokenList = postfixExpr.split() #Scan tokenList for numbers or operators for token in tokenList: # If the token has a positive integer < 10 in it's first position, push the entire token if token[0] in "0123456789": operandStack.push(token) else: # When operator is encountered, evaluate it with the previous two operands operand2 = operandStack.pop() operand1 = operandStack.pop() result = doMath(token, int(operand1), int(operand2)) operandStack.push(result) return operandStack.pop()
def evalPostfix(self, result): #계산 s = Stack.Stack() try: for token in result: if token in "+-*/": val2 = s.pop() val1 = s.pop() if token == '+': s.push(val1 + val2) elif token == '-': s.push(val1 - val2) elif token == '*': s.push(val1 * val2) elif token == '/': s.push(val1 / val2) else: s.push(int(token)) return s.pop() except Exception: return None
def displayTreeWithStack(root): currentElement = root stack = Stack(currentElement, currentElement.value) while currentElement is not None: #printez elementul curent print(str(stack.top.key.key)) stack = stackPop(stack) if currentElement.left is not None: stack = stackPush(stack, currentElement.left, currentElement.left.value) if currentElement.right is not None: stack = stackPush(stack, currentElement.right, currentElement.right.value) if stack.top is not None: currentElement = stack.top.key else: currentElement = None
def toRegularTree(self,numberOfChildren = 2): #1) je ne vois pas en quoi le second paramètre est nécessaire, # le résultat de la méthode n'est d'ailleurs pas logique si # numberOfChildren est différent de 2 # je ne lui ai donné aucun rôle dans cette méthode afin d'éviter de potentielles erreurs #2) je ne crée pas l'arbre binaire à partir de l'arbre courant # car si jamais (et ce n'est pas le cas dans les tests fournis) # on désire créer un arbre m-aire avec m > 2 en tant qu'arbre courant, # on sera obligé de partir du niveau le plus bas.. cad l'urne de départ.. stack = Stack() current = self.__urn stack.push(current) while current.getSize() != 1: #push chaque niveau de l'arbre sur le stack current = current.getCompressed(2) stack.push(current) f = Queue() root = stack.pop().getBallot(0) #initialisation à la racine de l'arbre (taille du premier niveau = 1) tree = BinaryTree(str(root)+str(root.getIdentifier())) f.insert(tree) while not stack.isEmpty(): #tant qu'il y a des niveaux à rajouter level = stack.pop() #niveau à lier au niveau précédent i = 0 toModify = f.size() #nombre de noeuds du niveau précédent while i < toModify: #on ajoute un fils gauche et un fils droit à chacun de ces noeuds(un gauche minimum) n = f.remove() node = level.getBallot(i*2) #indice du fils gauche = indice du père * 2 n.insertLeft(str(node) + str(node.getIdentifier())) #ajout d'un fils gauche f.insert(n.getLeftChild()) #on ajoute le fils à la liste des noeuds qui doivent être modifiés if i*2+1 < level.getSize(): node = level.getBallot(i*2+1) #indice du fils droit = indice du père * 2 + 1 n.insertRight(str(node) + str(node.getIdentifier()))#ajout d'un fils droit f.insert(n.getRightChild()) #on ajoute le fils à la liste des noeuds qui doivent être modifiés i += 1 return tree
def __init__(self,size): ## initializes all the stacks and variables used to store info, and initializes stack object self.Stack = [] self.Explore1Stack = [] self.Explore2Stack = [] self.SolutionStack = [] self.linelist = [] self.myStack = Stack.myStack() self.size = size ## self.map stores the information for all the cells, each cell has four [0,0,0,0]'s ## the first grouping of 0's stores info about the solution, the second grouping stores info about the solution ## the third grouping stores info about the borders of the maze, and the fourth grouping stores info about the walls ## the four 0's in each one correspond the the West,South,East and North directions self.map = [[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]] for i in range(self.size + 2)] for i in range(self.size + 2)] self.win = GraphWin("My Maze",self.size*40+1,self.size*40+1) ## randomly chooses location for the entrance, exit and key self.entrance,self.exit,self.key = self.generatePoints()
def postEval0(): """Given a postfix expression, evaluate it""" symbolString = input("Input a postfix expression: ") tokens = symbolString.split() stack = Stack() for token in tokens: # Is the token an integer? if token.isdigit(): stack.push(int(token)) # otherwise, it must be an operator else: arg1 = stack.pop() arg2 = stack.pop() # You’ll have to write the applyOp function val = applyOp(token, arg1, arg2) stack.push(val) return stack.pop()