def main(fichier): s=stack.create() ind_char=stack.create() ind_ligne=stack.create() nb_ligne=0 in_channel = open(fichier, 'r') chaine="debut" while(chaine != ''): chaine=in_channel.readline() nb_ligne=nb_ligne+1 for i in range(len(chaine)): if(chaine[i]=="(" or chaine[i]=="[" or chaine[i]=="{") : stack.push(chaine[i],s) stack.push(i,ind_char) stack.push(nb_ligne,ind_ligne) elif(chaine[i]==")" or chaine[i]=="]" or chaine[i]=="}"): if(not (stack.is_empty(s))): if (stack.top(s)==getOpening(chaine[i])): stack.pop(s) else: print("Closed parenthese",chaine[i]," at line ",nb_ligne," char ",i," don't match the open parenthese ",stack.top(s)," at line ",stack.top(ind_ligne)," char ",stack.top(ind_char)) else: print("No open parenthese matching parenthese ",chaine[i]," at line ",nb_ligne," char ",i) chaine=in_channel.readline() if(not stack.is_empty(s)): print("Parenthese ",stack.top(s)," at line ",stack.top(nb_ligne)," char ",stack.top(nb_char)," has no matching closed parenthese.")
def solve_puzzle(red, green, blue): """ Takes in three stacks and then sorts them based on ball color. First it checks each ball in the red can. If the ball is green it goes in green, if the ball is red or blue it goes in blue. Then it looks at the blue can. If the ball is red it goes in the red, if it is blue it goes in the green. Lastly all the blue balls in the green can move back to the blue can and the stacks of balls will be sorted. The function also tracks the amount of moves the sorting process takes and returns it. Pre-Conditions: It is assumed that all balls will begin in the red can and that the green and blue cans are empty. :param red: Red Can :param green: Green Can :param blue: Blue Can :return: moves """ moves = 0 stack_list = [red, green, blue] while stack.is_empty(red) != True: top_val = stack.top(red) if top_val == "R" or top_val == "B": stack.pop(red) stack.push(blue, top_val) animate.animate_move(stack_list, 0, 2) else: stack.pop(red) stack.push(green, top_val) animate.animate_move(stack_list, 0, 1) moves += 1 while stack.is_empty(blue) != True: top_val = stack.top(blue) if top_val == "R": stack.pop(blue) stack.push(red, top_val) animate.animate_move(stack_list, 2, 0) else: stack.pop(blue) stack.push(green, top_val) animate.animate_move(stack_list, 2, 1) moves += 1 while stack.top(green) != "G": top_val = stack.top(green) stack.pop(green) stack.push(blue, top_val) animate.animate_move(stack_list, 1, 2) moves += 1 return moves
def moveOneValid(self): #after moveing the smallest left, there should #only be one valid move to make other than moving the 1. Make it! print "Move the smallest disk to the left" self.moveSmallestLeft() self.toString() print "" self.generateMoves() moves = self.validMoves #remove all moves that involve moving the 1 disk theonestack = None for stack in self.stacks: if stack.top() == 1: theonestack = self.stacks.index(stack) removeAll = [(theonestack, 0), (theonestack, 1), (theonestack, 2)] r = removeAll for move in r: if move[0] == move[1]: removeAll.remove(move) for move in removeAll: if move in self.validMoves: moves.remove(move) if (len(moves) > 1): print "error" elif self.validMoves: self.move(self.validMoves[0])
def moveOneValid(self): #after moveing the smallest left, there should #only be one valid move to make other than moving the 1. Make it! print "Move the smallest disk to the left" self.moveSmallestLeft() self.toString() print "" self.generateMoves() moves = self.validMoves #remove all moves that involve moving the 1 disk theonestack = None for stack in self.stacks: if stack.top() == 1: theonestack = self.stacks.index(stack) removeAll = [(theonestack,0),(theonestack,1),(theonestack,2)] r = removeAll for move in r: if move[0] == move[1]: removeAll.remove(move) for move in removeAll: if move in self.validMoves: moves.remove(move) if(len(moves) > 1): print "error" elif self.validMoves: self.move(self.validMoves[0])
def minimum_bracket_reversals(input_string): """ Calculate the number of reversals to fix the brackets Args: input_string(string): Strings to be used for bracket reversal calculation Returns: int: Number of breacket reversals needed """ if len(input_string) % 2 == 1: return -1 stack = Stack() count = 0 for bracket in input_string: if stack.is_empty(): stack.push(bracket) else: top = stack.top() if top != bracket: if top == "{": stack.pop() stack.push(bracket) while not stack.is_empty(): first = stack.pop() second = stack.pop() if first == "}" and second == "}": count += 1 elif first == '{' and second == '}': count += 2 elif first == '{' and second == '{': count += 1 return count
def validateEquation(valueStack, opStack): validChar = "+-*/%^(" topOp = stack.top(opStack) topValue = stack.top(valueStack) # Pop topValue stack.pop(valueStack) # This determines whether an equation can be solved or not if topOp in validChar: try: secValue = stack.top(valueStack) secValue = float(secValue) stack.push(valueStack, topValue) return True except ValueError: return False else: stack.push(valueStack, topValue) return True
def deliminate(cmd): op = cmd[0] if op == 'push': stack.push(num=int(cmd[1])) if op == 'pop': print(stack.pop()) if op == 'size': print(stack.size()) if op == 'empty': print(stack.empty()) if op == 'top': print(stack.top())
def moveSmallestLeft(self): fromstack = None tostack = None for stack in self.stacks: if stack.top() == 1: fromstack = self.stacks.index(stack) tostack = fromstack - 1 if tostack == -1: tostack = 2 print "One is on: %d and one left of that is %d" %(fromstack,tostack) self.move((fromstack, tostack))
def moveSmallestLeft(self): fromstack = None tostack = None for stack in self.stacks: if stack.top() == 1: fromstack = self.stacks.index(stack) tostack = fromstack - 1 if tostack == -1: tostack = 2 print "One is on: %d and one left of that is %d" % (fromstack, tostack) self.move((fromstack, tostack))
def verif_parentheses(chaine): s=stack.create() for i in range(len(chaine)): """ print(s) """ if(chaine[i]=="(" or chaine[i]=="[" or chaine[i]=="{") : stack.push(chaine[i],s) elif(chaine[i]==")" or chaine[i]=="]" or chaine[i]=="}"): if(not (stack.is_empty(s)) and stack.top(s)==getOpening(chaine[i])): stack.pop(s) else: return -1 if(stack.is_empty(s)): return 1 else: return 0
def inOrder(node): stack = stack.stack() stack.push(node) finished = False while not stack.empty(): top = stack.top() if finished: print('{}'.format(top.data)) stack.pop() if top.right != None: stack.push(top.right) finished = False elif top.left != None: stack.push(top.left) else: print('{}'.format(top.data)) if top.right != None: stack.push(top.right) finished = False else: finished = True # leaf stack.pop()
def postOrder(node): stack = stack.stack() stack.push(node) lastest = None while not stack.empty(): top = stack.top() if top.left == lastest and top.right == None: print('{}'.format(top.data)) lastest = top stack.pop() elif top.right == lastest: print('{}'.format(top.data)) lastest = top stack.pop() else: if top.right != None: stack.push(top.right) if top.left != None: stack.push(top.left) if top.left == None and top.right == None: print('{}'.format(top.data)) lastest = top stack.pop()
import stack """ Ask the user to enter a series of braces and parentheses, then indicate if they are properly nested """ char = input('Enter parentheses and/or braces: ') sequence = stack.getStack() #for every element in the received string checks the type and pushes/pops in/from the stack for el in char: if el == '(' or el == '{': stack.push(sequence, el) elif not stack.isEmpty(sequence): if el == ')' and stack.top(sequence) == '(': stack.pop(sequence) elif el == '}' and stack.top(sequence) == '{': stack.pop(sequence) #Final check if the stack is empty #If it's empty the string is proper if stack.isEmpty(sequence): print('Nested properly.') else: print('Not properly nested.')
def stackPush(listEquation, inputPriority, stackPriority): valueStack = stack.stack() opStack = stack.stack() inputStack = stack.stack() stack.push(valueStack, "$") stack.push(opStack, "$") stack.push(inputStack, -1) # To count the number of elements in the equation list count = 0 for i in listEquation: count += 1 print("Looking at", i, "in the equation") if i in "123456789": stack.push(valueStack, i) print("Adding", i, "to valueStack") elif i in "+-*/%^(": # This solves the part of the equation before this, until the new # input priority can be put in while inputPriority [i] <= stack.top(inputStack): print("STACK VALUE >= the new INPUT PRIORITY.", end = " ") print("So pop and process, and recheck.") newValue = getValues(valueStack, inputStack, opStack) newValue = float(newValue) print("New answer being placed into the VALUE", end = " ") print("stack is: ", newValue) stack.push(valueStack, newValue) stack.push(opStack, i) print(i, "was just added to opStack") stack.push(inputStack, stackPriority [i]) print(stackPriority [i], "was just added to inputStack") elif i == ")": print("Pop and process, found a )") while stack.top(opStack) != "(" and stack.top(opStack) != "$": newValue = getValues(valueStack, inputStack, opStack) newValue = float(newValue) print("New answer being placed into the VALUE", end = " ") print("stack is: ", newValue) stack.push(valueStack, newValue) # This makes sure that there is a '(' in the equation if stack.top(opStack) == "$": print("ERROR: unable to solve equation") return else: stack.pop(opStack) stack.pop(inputStack) if len(listEquation) == count: boolean = False # This determines if the equation has been solved or not if stack.top(valueStack) == "$" and stack.top(opStack) == "$": try: stack.push(valueStack, newValue) boolean = True except UnboundLocalError: print("ERROR: unable to solve equation") return while boolean == False: print("END OF EQUATION, so pop and process until", end = " ") print("opStack is only a '$'") topValue = stack.top(valueStack) # Solves for errors if stack.top(valueStack) == "$" and stack.top(opStack) != "$": print("ERROR: unable to solve equation") return stack.pop(valueStack) topValue = float(topValue) if stack.top(valueStack) == "$" and stack.top(opStack) == "$": print("The answer is ", topValue) return stack.push(valueStack, topValue) bool2 = validateEquation(valueStack, opStack) if bool2 == False: print("ERROR: unable to solve equation") return newValue = getValues(valueStack, inputStack, opStack) # Catches this error if newValue == "???": print("ERROR: unable to solve equation") return newValue = float(newValue) print("New answer being placed into the VALUE", end = " ") print("stack is: ", newValue) if stack.top(valueStack) == "$" and stack.top(opStack) == "$": stack.push(valueStack, newValue) boolean = True else: stack.push(valueStack, newValue) newValue = stack.pop(valueStack) print("The answer is ", float(newValue))
# import stack module import stack # user input pa = input("Enter parentheses and/or braces: ") # define pa_stack pa_stack = stack.getStack() for i in range(0, len(pa)): # when character is left parentheses or braces push to the stack if pa[i] == "(" or pa[i] == "{": stack.push(pa_stack, pa[i]) # when character is right parentheses or braces pop the stack # if the value of the stack for top is left parentheses or braces else: if stack.top(pa_stack) == "(" and pa[i] == ")": stack.pop(pa_stack) elif stack.top(pa_stack) == "{" and pa[i] == "}": stack.pop(pa_stack) # output "Nested properly." when stack is empty if stack.isEmpty(pa_stack): print("Nested properly.") else: print("Not properly nested.")
if item in operator: operand_last = stack.pop(oper_stack) operand_second_last = stack.pop(oper_stack) if operand_second_last == None: # print('stack underflow') termination() else: stack.push(oper_stack, operation(item, operand_last, operand_second_last)) elif item == '=': right_most_position = False else: stack.push(oper_stack, int(item)) # The result will be stored on the last of oper_stack result = stack.top(oper_stack) # If result is None, it means the input is only one = # If oper_stack have more than 1 arguments, it means operator is not sufficient if result == None: # print('one =') termination() if len(oper_stack) > 1: # print('two or more') termination() if stack.top(slot) != '=': # print('no =') termination() if type(result) == float: if float.is_integer(result):
s = stack.getStack() proper = True # Make times to run while loop i = 0 i_limit = len(inp) while proper and i < i_limit: item = inp[i] # Left things will be had push if item == '(' or item == '{' or item == '[': stack.push(s, item) # Right things will be had pop and be found that it is matched properly else: top_stack = stack.top(s) if item == ')' and top_stack == '(': stack.pop(s) elif item == '}' and top_stack == '{': stack.pop(s) elif item == ']' and top_stack == '[': stack.pop(s) else: proper = False # # for item in inp: # if item == '(' or item == '{' or item == '[': # stack.push(s, item) # elif item == ')' or item == '}' or item == ']': # if item == stack.top(s): # stack.pop(s)