def toBase(decimal,base): # if base is greater than 16, raise error if base >16 or base <=0: raise ValueError ('base must be between 1 and 16') elif isinstance(decimal,int)==False: raise ValueError('the number must be a integer') elif decimal==0: return str(0) hex_num = "0123456789ABCDEF" s = Stack() while decimal > 0: remainder = decimal % base s.push(remainder) decimal = decimal // base output = "" # want to pop all the stack contents out while not s.isEmpty(): #hex_num[s.pop()] would make sure base>10, the alphabet would be used output += hex_num[s.pop()] return output #testing # print(toBase(101,2)) # should be 1100101 # print(toBase(101,16)) # should be 65 # print(toBase(188,16)) # should be BC
class QueueUsingStack: ''' Implementing Queue using two stacks We implement only enqueue and dequeue methods ''' def __init__(self): self.a_stack = Stack(20) self.b_stack = Stack(20) def enqueue(self, x): self.a_stack.push(x) print("Enqueueing element: {}\n".format(x)) print("A Stack: ", end="") self.a_stack.print() print("B Stack: ", end="") self.b_stack.print() print("---------------------------------------------") def dequeue(self): if not self.b_stack.isEmpty(): element = self.b_stack.pop() else: while (self.a_stack.top != 0): x = self.a_stack.pop() self.b_stack.push(x) element = self.a_stack.pop() print("Dequeued element: {}\n".format(element)) print("A Stack: ", end="") self.a_stack.print() print("B Stack: ", end="") self.b_stack.print() print("---------------------------------------------") return element
def infixToPostfix(infixexpr): from stacks import Stack from string import digits, ascii_uppercase print(infixexpr) infixexpr = infixexpr.replace('**', '^') print(infixexpr) tokenList = ''.join( [' ' + x + ' ' if not x in digits else x for x in infixexpr]) tokenList = tokenList.split() print(tokenList) prec = {} prec['^'] = 4 prec['*'] = 3 prec['/'] = 3 prec['+'] = 2 prec['-'] = 2 prec['('] = 1 postfixList = [] opStack = Stack() for token in tokenList: if token in ascii_uppercase or token.isdigit(): postfixList.append(token) elif token == '(': opStack.push(token) elif token == ')': if not opStack.isEmpty(): topStack = opStack.pop() while not opStack.isEmpty() and topStack != '(': postfixList.append(topStack) topStack = opStack.pop() else: while not opStack.isEmpty() and prec[ opStack.peek()] >= prec[token]: postfixList.append(opStack.pop()) opStack.push(token) while not opStack.isEmpty(): postfixList.append(opStack.pop()) result = ' '.join(postfixList) result = result.replace('^', '**') return result
def sortAscendingOrder(s1): s2 = Stack() while not s1.isEmpty(): # print 'S2:', s2.stack() # print 'S1:', s1.stack() last = s1.pop() while (not s2.isEmpty() and s2.peek() > last): s1.push(s2.pop()) s2.push(last) return s2
def deciToBin(num): binaryStack = Stack() binNum = "" print(f"The binary of {num} is: ", end="") while num > 0: binaryStack.push(num % 2) num = num // 2 while not (binaryStack.isEmpty()): binNum += str(binaryStack.peek()) binaryStack.pop() print(binNum)
def searchDFSTrace(graph, start, end): stack = Stack() stack.push([start]) while not stack.isEmpty(): path = stack.pop() last = path[-1] if last == end: return path for adjacent in graph.get(last, []): new_path = list(path) new_path.append(adjacent) stack.push(new_path)
def balanceCheck(strng): brackets = Stack() index = 0 isBalanced = True while index < len(strng) and isBalanced: content = strng[index] ending = content in ")}]" if not (brackets.isEmpty()): if ending: brackets.pop() else: brackets.push(content) elif ending and brackets.isEmpty(): isBalanced = False else: brackets.push(content) index += 1 if isBalanced: print("It is balanced!") else: print("It is unbalanced!")
def searchDFS(graph, start): visited = [] stack = Stack() stack.push(start) while not stack.isEmpty(): vertex = stack.pop() if vertex not in visited: visited.append(vertex) print "VERTEX", vertex for edges in graph[vertex]: stack.push(edges) return visited
def searchDFS(graph, start): visited = [] stack = Stack() stack.push(start) while not stack.isEmpty(): vertex = stack.pop() if vertex not in visited: visited.append(vertex) print 'VERTEX', vertex for edges in graph[vertex]: stack.push(edges) return visited
def stringReverse(s: str) -> str: #Creating a Stack Object stack = Stack() #For every character in string push to stack for x in s: stack.push(x) revStr = "" #The string to be returned #While the stack is not empty while not stack.isEmpty(): #Add the popped element to the revStr revStr += stack.pop() return revStr
def isBracketBalanced(valueString): s = Stack() index = 0 isBalanced = True while index < len(valueString) and isBalanced: character = valueString[index] if character in "([{": s.push(character) else: if s.isEmpty(): isBalanced = False else: top = s.pop() if not isMatch(top, character): isBalanced = False index += 1 if s.isEmpty() and isBalanced: return True else: return False
def divideBy2(decNumber): remStack = Stack() while decNumber > 0: rem = decNumber % 2 remStack.push(rem) decNumber = decNumber // 2 binString = "" while not remStack.isEmpty(): binString = binString + str(remStack.pop()) return binString
def convertBase(num, base=2): from stacks import Stack s = Stack() while num != 0: remainder = str(num % base) numList = ['10', '11', '12', '13', '14', '15'] if remainder in numList: remainder = 'ABCDEF'[numList.index(remainder)] s.push(remainder) num //= base convertedNum = '' while not s.isEmpty(): convertedNum += s.pop() return convertedNum
def integerToBinary(num: int) -> str: #Initialising the Stack Object s = Stack() ans = num while ans != 0: #Appending the remainder to the Stack s.push(ans % 2) #Storing the non decimal part of divison by floor divison ans = ans//2 binary = "" #While stack isn't empty pop into binary while not s.isEmpty(): binary += str(s.pop()) return binary
def isBracketBalanced(string: str) -> bool: bracketStack = Stack() isBalanced = True index = 0 while index < len(string) and isBalanced: x = string[index] if x in "({[": bracketStack.push(x) else: if bracketStack.isEmpty(): isBalanced = False else: top = bracketStack.pop() if not isAMatch(top, x): isBalanced = False index += 1 if bracketStack.isEmpty() and isBalanced: return True else: return False
def baseConverter(decNumber, base): digits = "0123456789ABCDEF" remStack = Stack() while decNumber > 0: rem = decNumber % base remStack.push(rem) decNumber = decNumber // base new_string = "" while not remStack.isEmpty(): new_string = new_string + digits[remStack.pop()] return new_string
def parenthesisChecker(parString): s = Stack() for sym in parString: # if it is a open parenthesis, push in if sym in "([{": s.push(sym) elif sym in ")]}": # if it is a close parenthesis but the stack is empty, return false if s.isEmpty(): return False else: top = s.pop() # the close parenthesis needs to match, if not match, return false if not parenthesisMatches(top, sym): return False # if everything goes well and did not return False early then the parString is fine and return True return True
def generateMaze(nodes): nodes.getEmptyGrid() index = randint(0, len(nodes.nodeList)-1) nodeEnd = nodes.nodeList[index] nodeEnd.visited = True allNodesVisited = False #print "start = " + str(index) stack = Stack() while not allNodesVisited: unvisitedNodes = nodes.getUnvisitedNodes() index = randint(0, len(unvisitedNodes)-1) nodeStart = unvisitedNodes[index] endFound = False stack.push(nodeStart) while not endFound: directionList = nodes.getDirections(stack.peek()) directionIndex = randint(0, len(directionList)-1) direction = directionList[directionIndex] nodeNext = nodes.getUnlinkedNode(stack.peek(), direction) if not nodeNext.visited: if stack.contains(nodeNext): while stack.peek() is not nodeNext: stack.pop() else: stack.push(nodeNext) else: #Carve out the path that is defined by the stack stack.push(nodeNext) endFound = True while not stack.isEmpty(): node1 = stack.pop() node2 = stack.peek() node1.visited = True if node2 is not None: #print node1, node2 direction = nodes.getDirectionFromNodes(node1, node2) nodes.addPath(node1, direction) else: stack.clear() unvisitedNodes = nodes.getUnvisitedNodes() if len(unvisitedNodes) == 0: allNodesVisited = True
def abs_to_relative_two(s): stack = Stack() index = 0 len_f = len(s) while index < len_f: while index< len_f and s[index] != '.': stack.push(s[index]) index += 1 point_count = 0 while index<len_f and s[index] == '.': index += 1 point_count += 1 if point_count == 2: stack.pop() while not stack.isEmpty() and stack.peer() != '/': stack.pop() index += 1 return ''.join(stack.items) # print relative path
def generateMaze(nodes): nodes.getEmptyGrid() index = randint(0, len(nodes.nodeList)-1) node = nodes.nodeList[index] node.visited = True allNodesVisited = False #print "start = " + str(node.row) + ", " + str(node.column) stack = Stack() #unvisitedNeighbors = nodes.getUnvisitedNeighbors(node) #print len(unvisitedNeighbors) stack.push(node) while not stack.isEmpty(): unvisitedNeighbors = nodes.getUnvisitedNeighbors(stack.peek()) #print "Unvisited Neighbors = " + str(len(unvisitedNeighbors)) if len(unvisitedNeighbors) > 0: index = randint(0, len(unvisitedNeighbors)-1) nodeNext = unvisitedNeighbors[index] direction = nodes.getDirectionFromNodes(stack.peek(), nodeNext) nodes.addPath(stack.peek(), direction) nodeNext.visited = True stack.push(nodeNext) else: stack.pop()
class Ghost(MazeMouse): def __init__(self, nodes, level, spritesheet): MazeMouse.__init__(self, nodes, level, spritesheet) self.name = "ghost" self.goal = Vector2D() self.modeStack = self.setupModeStack() self.mode = self.modeStack.pop() self.modeTimer = 0 self.homeNode = None self.startDirection = UP self.exitHome = True self.guideDog = False self.leftHome = True self.previousDirection = None def setGuideStack(self): self.guideStack = Stack() self.guideStack.push(LEFT) self.guideStack.push(UP) def getStartNode(self): node = MAZEDATA[self.level]["start"]["ghost"] return self.nodes.getNode(*node, nodeList=self.nodes.homeList) def setStartPosition(self): self.setHomeNode() self.direction = self.startDirection self.target = self.node.neighbors[self.direction] self.setPosition() self.checkDirectionChange() def checkDirectionChange(self): if self.direction != self.previousDirection: self.previousDirection = self.direction row = self.imageRow col = 0 if self.mode.name == "SPAWN": row, col = self.setSpawnImages() elif self.mode.name != "FREIGHT": if self.direction == LEFT: col = 4 elif self.direction == RIGHT: col = 6 elif self.direction == DOWN: col = 2 elif self.direction == UP: col = 0 self.setImage(row, col) def setImage(self, row, col): self.image = self.spritesheet.getImage(col, row, 32, 32) def setSpawnImages(self): row = 6 if self.direction == LEFT: col = 6 elif self.direction == RIGHT: col = 7 elif self.direction == DOWN: col = 4 elif self.direction == UP: col = 5 return row, col def getClosestDirection(self, validDirections): distances = [] for direction in validDirections: diffVec = self.node.position + direction * WIDTH - self.goal distances.append(diffVec.magnitudeSquared()) index = distances.index(min(distances)) return validDirections[index] def getValidDirections(self): validDirections = [] for key in self.node.neighbors.keys(): if self.node.neighbors[key] is not None: if not key == self.direction * -1: validDirections.append(key) if len(validDirections) == 0: validDirections.append(self.forceBacktrack()) if (self.node.home and DOWN in validDirections and self.mode.name != "SPAWN"): validDirections.remove(DOWN) if self.node.nowayUp and UP in validDirections: validDirections.remove(UP) if not self.leftHome: if self.exitHome: validDirections = self.guideOutOfHome(validDirections) else: validDirections = self.trapInHome(validDirections) return validDirections def randomDirection(self, validDirections): index = randint(0, len(validDirections) - 1) return validDirections[index] def moveBySelf(self): if self.overshotTarget(): self.node = self.target self.portal() validDirections = self.getValidDirections() self.direction = self.getClosestDirection(validDirections) self.target = self.node.neighbors[self.direction] self.setPosition() if self.mode.name == "SPAWN": if self.position == self.goal: self.mode = self.modeStack.pop() def forceBacktrack(self): if self.direction * -1 == UP: return UP if self.direction * -1 == DOWN: return DOWN if self.direction * -1 == LEFT: return LEFT if self.direction * -1 == RIGHT: return RIGHT def setupModeStack(self): modes = Stack() modes.push(Mode(name="CHASE")) modes.push(Mode(name="SCATTER", time=5)) modes.push(Mode(name="CHASE", time=20)) modes.push(Mode(name="SCATTER", time=7)) modes.push(Mode(name="CHASE", time=20)) modes.push(Mode(name="SCATTER", time=7)) modes.push(Mode(name="CHASE", time=20)) modes.push(Mode(name="SCATTER", time=7)) return modes def setScatterGoal(self): self.goal = Vector2D() def setChaseGoal(self, pacman): self.goal = pacman.position def modeUpdate(self, dt): self.modeTimer += dt if self.mode.time is not None: if self.modeTimer >= self.mode.time: self.reverseGhostDirection() self.mode = self.modeStack.pop() self.modeTimer = 0 def update(self, dt, pacman, blinky): speedMod = self.modifySpeed() self.position += self.direction * speedMod * dt self.modeUpdate(dt) if self.mode.name == "CHASE": self.setChaseGoal(pacman, blinky) elif self.mode.name == "SCATTER": self.setScatterGoal() elif self.mode.name == "FREIGHT": self.setRandomGoal() elif self.mode.name == "SPAWN": self.setSpawnGoal() self.moveBySelf() if self.mode.name != "FREIGHT": self.checkDirectionChange() else: if (self.mode.time - self.modeTimer) < 1: self.setImage(6, 2) def modifySpeed(self): if (self.node.portalNode is not None or self.target.portalNode is not None): return self.speed / 2.0 return self.speed * self.mode.speedMult def setFreightMode(self): if self.mode.name != "SPAWN": if self.mode.name != "FREIGHT": if self.mode.time is not None: dt = self.mode.time - self.modeTimer self.modeStack.push(Mode(name=self.mode.name, time=dt)) else: self.modeStack.push(Mode(name=self.mode.name)) self.reverseGhostDirection() self.mode = Mode("FREIGHT", time=7, speedMult=0.5) self.modeTimer = 0 else: self.mode = Mode("FREIGHT", time=7, speedMult=0.5) self.modeTimer = 0 self.setImage(6, 0) def setRandomGoal(self): x = randint(0, NCOLS * WIDTH) y = randint(0, NROWS * HEIGHT) self.goal = Vector2D(x, y) def setRespawnMode(self): self.mode = Mode("SPAWN", speedMult=2) self.modeTimer = 0 self.setGuideStack() self.leftHome = False def setSpawnGoal(self): self.goal = self.homeNode.position def trapInHome(self, validDirections): if LEFT in validDirections: validDirections.remove(LEFT) if RIGHT in validDirections: validDirections.remove(RIGHT) return validDirections def guideOutOfHome(self, validDirections): if not self.guideDog: if self.target == self.homeNode: self.guideDog = True validDirections = [] validDirections.append(self.guideStack.pop()) else: validDirections = [] validDirections.append(self.guideStack.pop()) if self.guideStack.isEmpty(): self.guideDog = False self.leftHome = True return validDirections def reverseGhostDirection(self): if self.leftHome: self.reverseDirection()
class NodeGroup(object): def __init__(self, width, height): '''width and height are the minimum distance between nodes''' self.nodeList = [] self.width = width self.height = height self.grid = None self.nodeStack = Stack() self.fRows = 0 self.fCols = 0 def getNode(self, row, col): '''Get the node from the nodeList given the row and col''' for node in self.nodeList: if node.row == row and node.col == col: return node return None def getNodeFromNode(self, node): '''Checks list of node already exists, if so get that node. If node does not exist, then return the input node''' if node is not None: #return self.getNode(node.row, node.col) for inode in self.nodeList: if node.row == inode.row and node.col == inode.col: return inode return node def findFirstNodeInGrid(self, rows, cols): '''Searches grid until it runs into a node, return that Node''' nodeFound = False for row in range(rows): for col in range(cols): if self.grid[row][col] == "+": return Node(col, row, self.width, self.height) return None def addNode(self, node): '''Add a node to the nodeList if not already in the list''' nodeInList = self.nodeInList(node) if not nodeInList: self.nodeList.append(node) def nodeInList(self, node): '''Return True if the node is already in nodeList''' for inode in self.nodeList: if node.row == inode.row and node.col == inode.col: return True return False def createNodeListFromFile(self, filename): '''Creates a connected nodelist from a properly formatted file''' self.grid = loadtxt(filename, dtype=str) self.fRows, self.fCols = self.grid.shape startNode = self.findFirstNodeInGrid(self.fRows, self.fCols) self.nodeStack.push(startNode) # print self.grid.shape while not self.nodeStack.isEmpty(): node = self.nodeStack.pop() self.addNode(node) leftNode = self.followPath(LEFT, node.row, node.col) rightNode = self.followPath(RIGHT, node.row, node.col) upNode = self.followPath(UP, node.row, node.col) downNode = self.followPath(DOWN, node.row, node.col) leftNode = self.getNodeFromNode(leftNode) rightNode = self.getNodeFromNode(rightNode) upNode = self.getNodeFromNode(upNode) downNode = self.getNodeFromNode(downNode) node.neighbors[LEFT] = leftNode node.neighbors[RIGHT] = rightNode node.neighbors[UP] = upNode node.neighbors[DOWN] = downNode if leftNode is not None and not self.nodeInList(leftNode): self.nodeStack.push(leftNode) if rightNode is not None and not self.nodeInList(rightNode): self.nodeStack.push(rightNode) if upNode is not None and not self.nodeInList(upNode): self.nodeStack.push(upNode) if downNode is not None and not self.nodeInList(downNode): self.nodeStack.push(downNode) def followPath(self, direction, row, col): if direction == LEFT and col-1 >= 0: if self.grid[row][col-1] == "-" or self.grid[row][col-1] == "+": while self.grid[row][col-1] != "+": col -= 1 return Node(col-1, row, self.width, self.height) else: return None elif direction == RIGHT and col+1 < self.fCols: if self.grid[row][col+1] == "-" or self.grid[row][col+1] == "+": while self.grid[row][col+1] != "+": col += 1 return Node(col+1, row, self.width, self.height) else: return None elif direction == UP and row-1 >= 0: if self.grid[row-1][col] == "|" or self.grid[row-1][col] == "+": while self.grid[row-1][col] != "+": row -= 1 return Node(col, row-1, self.width, self.height) else: return None elif direction == DOWN and row+1 < self.fRows: if self.grid[row+1][col] == "|" or self.grid[row+1][col] == "+": while self.grid[row+1][col] != "+": row += 1 return Node(col, row+1, self.width, self.height) else: return None else: return None def render(self, screen): for node in self.nodeList: node.render(screen)
class NodeGroup(object): def __init__(self, level): self.level = level self.nodeList = [] self.grid = None self.nodeStack = Stack() self.nodeSymbols = ["+", "n", "N", "M", "H", "F"] self.homeList = [] self.createMainList() self.createHomeList() def createMainList(self): self.createNodeList(MAZEDATA[self.level]["file"], self.nodeList) self.setupPortalNodes() def createHomeList(self): self.createNodeList("home.txt", self.homeList) self.moveHomeNodes() def createNodeList(self, textFile, nodeList): self.grid = loadtxt(textFile, dtype=str) startNode = self.findFirstNode(*self.grid.shape) self.nodeStack.push(startNode) while not self.nodeStack.isEmpty(): node = self.nodeStack.pop() self.addNode(node, nodeList) leftNode = self.getPathNode(LEFT, node.row, node.column-1, nodeList) rightNode = self.getPathNode(RIGHT, node.row, node.column+1, nodeList) upNode = self.getPathNode(UP, node.row-1, node.column, nodeList) downNode = self.getPathNode(DOWN, node.row+1, node.column, nodeList) node.neighbors[LEFT] = leftNode node.neighbors[RIGHT] = rightNode node.neighbors[UP] = upNode node.neighbors[DOWN] = downNode self.addNodeToStack(leftNode, nodeList) self.addNodeToStack(rightNode, nodeList) self.addNodeToStack(upNode, nodeList) self.addNodeToStack(downNode, nodeList) self.setupPortalNodes() def getNode(self, x, y, nodeList=[]): for node in nodeList: if node.position.x == x and node.position.y == y: return node return None def getNodeFromNode(self, node, nodeList): if node is not None: for inode in nodeList: if node.row == inode.row and node.column == inode.column: return inode return node def getPathNode(self, direction, row, col, nodeList): tempNode = self.followPath(direction, row, col) self.checkIfOnRestriction(tempNode) return self.getNodeFromNode(tempNode, nodeList) def findFirstNode(self, rows, cols): nodeFound = False for row in range(rows): for col in range(cols): if self.grid[row][col] in self.nodeSymbols: return Node(row, col) return None def addNode(self, node, nodeList): nodeInList = self.nodeInList(node, nodeList) if not nodeInList: nodeList.append(node) def addNodeToStack(self, node, nodeList): if node is not None and not self.nodeInList(node, nodeList): self.nodeStack.push(node) def nodeInList(self, node, nodeList): for inode in nodeList: if (node.position.x == inode.position.x and node.position.y == inode.position.y): return True return False def followPath(self, direction, row, col): if direction == LEFT and col >= 0: return self.pathToFollow(LEFT, row, col, "-") elif direction == RIGHT and col < self.grid.shape[1]: return self.pathToFollow(RIGHT, row, col, "-") elif direction == UP and row >= 0: return self.pathToFollow(UP, row, col, "|") elif direction == DOWN and row < self.grid.shape[0]: return self.pathToFollow(DOWN, row, col, "|") else: return None def pathToFollow(self, direction, row, col, path): if (self.grid[row][col] == path or self.grid[row][col] == "p" or self.grid[row][col] == "P" or self.grid[row][col] == "+"): while self.grid[row][col] not in self.nodeSymbols: if direction is LEFT: col -= 1 elif direction is RIGHT: col += 1 elif direction is UP: row -= 1 elif direction is DOWN: row += 1 self.updateMazeData(self.grid[row][col], row, col) return Node(row, col) else: return None def updateMazeData(self, symbol, row, col): if symbol == "M": MAZEDATA[self.level]["start"]["pacman"] = (col*WIDTH, row*HEIGHT) elif symbol == "H": MAZEDATA[self.level]["home"] = (col*WIDTH, row*HEIGHT) elif symbol == "F": MAZEDATA[self.level]["fruit"] = (col*WIDTH, row*HEIGHT) def setupPortalNodes(self): for pos1 in MAZEDATA[self.level]["portal"].keys(): node1 = self.getNode(*pos1, nodeList=self.nodeList) node2 = self.getNode(*MAZEDATA[self.level]["portal"][pos1], nodeList=self.nodeList) node1.portalNode = node2 node2.portalNode = node1 def moveHomeNodes(self): nodeA = self.getNode(*MAZEDATA[self.level]["home"], nodeList=self.nodeList) nodeB = nodeA.neighbors[LEFT] mid = (nodeA.position + nodeB.position) / 2.0 mid = Vector2D(int(mid.x), int(mid.y)) vec = Vector2D(self.homeList[0].position.x, self.homeList[0].position.y) for node in self.homeList: node.position -= vec node.position += mid nodeA.neighbors[LEFT] = self.homeList[0] nodeB.neighbors[RIGHT] = self.homeList[0] self.homeList[0].neighbors[RIGHT] = nodeA self.homeList[0].neighbors[LEFT] = nodeB self.homeList[0].home = True ghostHome = self.homeList[0].neighbors[DOWN] MAZEDATA[self.level]["start"]["ghost"] = ghostHome.position.toTuple() def checkIfOnRestriction(self, node): if node is not None: for tup in MAZEDATA[self.level]["restrictUp"].values(): if node.position.x == tup[0] and node.position.y == tup[1]: node.nowayUp = True def setupTestNodes(self): nodeA = Node(5, 5) nodeB = Node(5, 10) nodeC = Node(10, 5) nodeD = Node(10, 10) nodeE = Node(10, 13) nodeF = Node(20, 5) nodeG = Node(20, 13) nodeA.neighbors[RIGHT] = nodeB nodeA.neighbors[DOWN] = nodeC nodeB.neighbors[LEFT] = nodeA nodeB.neighbors[DOWN] = nodeD nodeC.neighbors[UP] = nodeA nodeC.neighbors[RIGHT] = nodeD nodeC.neighbors[DOWN] = nodeF nodeD.neighbors[UP] = nodeB nodeD.neighbors[LEFT] = nodeC nodeD.neighbors[RIGHT] = nodeE nodeE.neighbors[LEFT] = nodeD nodeE.neighbors[DOWN] = nodeG nodeF.neighbors[UP] = nodeC nodeF.neighbors[RIGHT] = nodeG nodeG.neighbors[UP] = nodeE nodeG.neighbors[LEFT] = nodeF self.nodeList = [nodeA, nodeB, nodeC, nodeD, nodeE, nodeF, nodeG] def render(self, screen): for node in self.nodeList: node.render(screen) for node in self.homeList: node.render(screen)
class NodeGroup(object): def __init__(self, width, height): self.nodeList = [] self.width = width self.height = height self.grid = None self.nodeStack = Stack() self.fRows = 0 self.fCols = 0 # Creates nodelist def getBoardNodes(self, filename): self.grid = loadtxt(filename, dtype=str) self.fRows, self.fCols = self.grid.shape startNode = self.initNodes(self.fRows, self.fCols) self.nodeStack.push(startNode) while not self.nodeStack.isEmpty(): node = self.nodeStack.pop() self.addNode(node) leftNode = self.folDirect(LEFT, node.row, node.col) rightNode = self.folDirect(RIGHT, node.row, node.col) upNode = self.folDirect(UP, node.row, node.col) downNode = self.folDirect(DOWN, node.row, node.col) leftNode = self.getNodeFromNode(leftNode) rightNode = self.getNodeFromNode(rightNode) upNode = self.getNodeFromNode(upNode) downNode = self.getNodeFromNode(downNode) node.neighbors[LEFT] = leftNode node.neighbors[RIGHT] = rightNode node.neighbors[UP] = upNode node.neighbors[DOWN] = downNode if leftNode is not None and not self.listedNodes(leftNode): self.nodeStack.push(leftNode) if rightNode is not None and not self.listedNodes(rightNode): self.nodeStack.push(rightNode) if upNode is not None and not self.listedNodes(upNode): self.nodeStack.push(upNode) if downNode is not None and not self.listedNodes(downNode): self.nodeStack.push(downNode) def getNode(self, row, col): for node in self.nodeList: if node.row == row and node.col == col: return node return None def getNodeFromNode(self, node): if node is not None: for inode in self.nodeList: if node.row == inode.row and node.col == inode.col: return inode return node def initNodes(self, rows, cols): nodeFound = False for row in range(rows): for col in range(cols): if self.grid[row][col] == "+": return Node(col, row, self.width, self.height) return None # Add node to list def addNode(self, node): nodeInList = self.listedNodes(node) if not nodeInList: self.nodeList.append(node) # Checks if node is already in list def listedNodes(self, node): for inode in self.nodeList: if node.row == inode.row and node.col == inode.col: return True return False def folDirect(self, direction, row, col): if direction == LEFT and col - 1 >= 0: if self.grid[row][col - 1] == "-" or self.grid[row][col - 1] == "+": while self.grid[row][col - 1] != "+": col -= 1 return Node(col - 1, row, self.width, self.height) else: return None elif direction == RIGHT and col + 1 < self.fCols: if self.grid[row][col + 1] == "-" or self.grid[row][col + 1] == "+": while self.grid[row][col + 1] != "+": col += 1 return Node(col + 1, row, self.width, self.height) else: return None elif direction == UP and row - 1 >= 0: if self.grid[row - 1][col] == "|" or self.grid[row - 1][col] == "+": while self.grid[row - 1][col] != "+": row -= 1 return Node(col, row - 1, self.width, self.height) else: return None elif direction == DOWN and row + 1 < self.fRows: if self.grid[row + 1][col] == "|" or self.grid[row + 1][col] == "+": while self.grid[row + 1][col] != "+": row += 1 return Node(col, row + 1, self.width, self.height) else: return None else: return None def render(self, screen): for node in self.nodeList: node.render(screen)