def bf_traverse(self): q = ArrayQueue() if self.r != self.nil: q.add(self.r) while q.size() > 0: u = q.remove() if u.left != self.nil: q.add(u.left) if u.right != self.nil: q.add(u.right)
def stack_to_queue(stack): """ Converts the stack to a queue. """ q = ArrayQueue() for i in list(stack)[::-1]: q.add(i) return q
def stack_to_queue(stack): ''' Conver stack to queue. ''' stack_copy = deepcopy(stack) queue = ArrayQueue() while stack_copy: queue.add(stack_copy.pop()) return queue
def stackToQueue(stack): stack_copy = copy.deepcopy(stack) queue = ArrayQueue() while True: try: queue.add(stack_copy.pop()) except KeyError: break return queue
def stack_to_queue(stack): """ Convert stack to queue """ queue = ArrayQueue() while len(stack) != 0: num = stack.pop() queue.add(num) return queue
def stack_to_queue(stack): '''Convert stack to queue, without changing given stack peek of the stack is the first element in the queue''' queue = ArrayQueue() stack_copy = ArrayStack(stack) while len(stack_copy) != 0: queue.add(stack_copy.pop()) return queue
def stack_to_queue(stack): """Converts stack to a queue""" start_stack = copy.deepcopy(stack) output_queue = ArrayQueue() while start_stack.isEmpty() is False: elem = start_stack.pop() output_queue.add(elem) return output_queue
def stack_to_queue(stack: ArrayStack) -> ArrayQueue: """ Converts stack to queue and returns Queue object """ queue = ArrayQueue() copy_of_stack = deepcopy(stack) while not copy_of_stack.isEmpty(): queue.add(copy_of_stack.pop()) return queue
def stack_to_queue(stack): """ Converts stack to queue. """ list_stack = [] for i in stack: list_stack.append(i) list_queue = list_stack[::-1] new_queue = ArrayQueue() for j in range(len(list_stack)): new_queue.add(list_queue[j]) return new_queue
def stack_to_queue(stack): """ Converts stack to queue. """ temp_stack = ArrayStack() result_queue = ArrayQueue() while not stack.isEmpty(): elem = stack.pop() result_queue.add(elem) temp_stack.push(elem) while not temp_stack.isEmpty(): stack.push(temp_stack.pop()) return result_queue
def stack_to_queue(stack): """ Return queue from stack (front of queue is peek of stack). """ copy_stack = ArrayStack() queue = ArrayQueue() for element in stack: copy_stack.push(element) while len(copy_stack) != 0: queue.add(copy_stack.pop()) return queue
class Cashier(object): """Represents a cashier.""" def __init__(self, number): """Maintains a cashier number, a queue of customers, number of customers served, total customer wait time, and a current customer being processed.""" self._number = number self._totalCustomerWaitTime = 0 self._customersServed = 0 self._currentCustomer = None self._queue = ArrayQueue() def addCustomer(self, c): """Adds an arriving customer to my line.""" self._queue.add(c) def serveCustomers(self, currentTime): """Serves my cuatomers during a given unit of time.""" if self._currentCustomer is None: # No customers yet if self._queue.isEmpty(): return else: # Pop first waiting customer and tally results self._currentCustomer = self._queue.pop() self._totalCustomerWaitTime += \ currentTime - \ self._currentCustomer.arrivalTime() self._customersServed += 1 # Give a unit of service self._currentCustomer.serve() # If current customer is finished, send it away if self._currentCustomer.amountOfServiceNeeded() == 0: self._currentCustomer = None def __str__(self): """Returns my results: my number, my total customers served, my average wait time per customer, and customers left on my queue.""" if self._customersServed != 0: aveWaitTime = float(self._totalCustomerWaitTime) /\ self._customersServed else: aveWaitTime = 0.0 result = "%4d %8d %13.2f %8d" % (self._number, self._customersServed, aveWaitTime, len(self._queue)) return result
def queue_to_stack(queue: ArrayQueue) -> ArrayStack: """ Return stack from queue (front of queue is peek of stack). """ copy_queue = ArrayQueue() stack = ArrayStack() for element in queue: copy_queue.add(element) reversed_queue = reverse_queue(copy_queue) for element in reversed_queue: stack.push(element) return stack
def queue_to_stack(queue): """ Converts queue to stack. """ temp_queue = ArrayQueue() temp_stack = ArrayStack() #elements are in reversed order result_stack = ArrayStack() while not queue.isEmpty(): elem = queue.pop() temp_queue.add(elem) temp_stack.push(elem) while not temp_queue.isEmpty(): queue.add(temp_queue.pop()) while not temp_stack.isEmpty(): result_stack.push(temp_stack.pop()) #we reverse elements return result_stack
def main(): """ tests module. """ queue = ArrayQueue() for i in range(10): queue.add(i) stack = queue_to_stack(queue) assert str(queue) == "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]" assert str(stack) == "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]" assert stack.pop() == 0 assert queue.pop() == 0 stack.add(11) queue.add(11) assert str(queue) == '[1, 2, 3, 4, 5, 6, 7, 8, 9, 11]' assert str(stack) == "[9, 8, 7, 6, 5, 4, 3, 2, 1, 11]" print("Success!")
def stack_to_queue(stack): """ converts stack to queue """ stack_copy = ArrayStack(stack) queue = ArrayQueue() while True: try: element = stack_copy.pop() queue.add(element) except KeyError: break queue_reversed = ArrayQueue() while True: try: element = queue.pop() queue_reversed.add(element) except KeyError: break return queue_reversed
def bf_traverse(self): q = ArrayQueue() if self.r != self.nil: q.add(self.r) while q.size() > 0: u = q.remove() if u.left != self.nil: q.add(u.left) if u.right != self.nil: q.add(u.right)
from arrayqueue import ArrayQueue from arraystack import ArrayStack import random def queue_to_stack(queue): """ Convert queue to stack """ stack1 = ArrayStack() stack2 = ArrayStack() while len(queue) != 0: num = queue.pop() stack1.push(num) while len(stack1) != 0: num = stack1.pop() stack2.push(num) return stack2 if __name__ == '__main__': queue = ArrayQueue() stack = ArrayStack() for i in range(random.randint(5, 10)): m = random.randint(0, 10) queue.add(m) stack.push(m) print('Stack: ', stack) print('Queue: ', queue_to_stack(queue))
def stack_to_queue(stack): queue = ArrayQueue() new_stack = copy.deepcopy(stack) while not new_stack.isEmpty(): queue.add(new_stack.pop()) return queue
from Queue.stack_to_queue import stack_to_queue from Stack.queue_to_stack import queue_to_stack from arraystack import ArrayStack from arrayqueue import ArrayQueue s = ArrayStack() s.push(1) s.push(2) s.push(3) q = stack_to_queue(s) print(s) print(q) q = ArrayQueue() q.add(1) q.add(2) q.add(3) s = queue_to_stack(q) print(s) print(q) print(s.pop())
def queueMaze(mazeText): #parses maze file and captures maze attributes mazeFile = open(mazeText, "r") mazeList = mazeFile.read().splitlines( ) #https://stackoverflow.com/questions/24946640/removing-r-n-from-a-python-list-after-importing-with-readlines mazeFile.close() rows = len(mazeList) columns = len(mazeList[0]) #builds blank grid maze = Grid(rows, columns) #builds maze from list of maze rows for row in range(maze.getHeight()): for column in range(maze.getWidth()): maze[row][column] = mazeList[row][column] #creates intersection queue queue = ArrayQueue() #creates a player player = Player(maze) #searches for starting point of player for r in range(0, rows): for c in range(0, columns): if maze[r][c] == "P": player.setRow(r) player.setColumn(c) break choicePoints = 0 #end condition check while maze[player.getRow()][player.getColumn() + 1] != 'T': #convenience variables representing the value of the grid at these positions relative to player up = maze[player.getRow() - 1][player.getColumn()] down = maze[player.getRow() + 1][player.getColumn()] right = maze[player.getRow()][player.getColumn() + 1] left = maze[player.getRow()][player.getColumn() - 1] #dead end check routes = 0 if up == ' ': routes += 1 if down == ' ': routes += 1 if right == ' ': routes += 1 if left == ' ': routes += 1 if routes == 0: #player is at a dead end. #retrieves the previous intersection from the queue pos = queue.pop() #backtracks the player to previous intersection maze[player.getRow()][player.getColumn()] = '-' player.setRow(pos.getRow()) player.setColumn(pos.getColumn()) maze[pos.getRow()][pos.getColumn()] = 'P' #marks last path as dead end maze[pos.getActivePath()[0]][pos.getActivePath()[1]] = '-' elif routes > 1: #player is at an intersection #increment choice points by 1 choicePoints += 1 intersection = Intersection(player.getRow(), player.getColumn()) if up == ' ': intersection.setActivePath( [player.getRow() - 1, player.getColumn()]) nextMove = player.moveUp() elif down == ' ': intersection.setActivePath( [player.getRow() + 1, player.getColumn()]) nextMove = player.moveDown() elif right == ' ': intersection.setActivePath( [player.getRow(), player.getColumn() + 1]) nextMove = player.moveRight() elif left == ' ': intersection.setActivePath( [player.getRow(), player.getColumn() - 1]) nextMove = player.moveLeft() queue.add(intersection) else: #the player is not at a dead end if down == ' ': nextMove = player.moveDown() elif up == ' ': nextMove = player.moveUp() elif right == ' ': nextMove = player.moveRight() elif left == ' ': nextMove = player.moveLeft() #moves player to the next position nextMove #moves P to the end of the maze maze[player.getRow()][player.getColumn()] = "-" maze[player.getRow()][player.getColumn() + 1] = "P" print("Queue-based Maze Solution:\n") print(maze) print("Choice points: " + str(choicePoints)) #writes maze solution to text file fw = open("queuesolution.txt", "w") fw.writelines(str(maze)) fw.write("Choice points: " + str(choicePoints) + "\n") fw.close()
Queue to stack converter. """ from arrayqueue import ArrayQueue from arraystack import ArrayStack def queue_to_stack(queue): """ Converts queue to stack. """ temp_queue = ArrayQueue() temp_stack = ArrayStack() #elements are in reversed order result_stack = ArrayStack() while not queue.isEmpty(): elem = queue.pop() temp_queue.add(elem) temp_stack.push(elem) while not temp_queue.isEmpty(): queue.add(temp_queue.pop()) while not temp_stack.isEmpty(): result_stack.push(temp_stack.pop()) #we reverse elements return result_stack queue = ArrayQueue() for i in range(10): queue.add(i) stack = queue_to_stack(queue) print(queue) print(stack)
# Get the queue items while True: try: converter_stack.push(input_queue.pop()) except KeyError: break # Reverse the queue while True: try: output_stack.push(converter_stack.pop()) except KeyError: break return output_stack if __name__ == "__main__": queue = ArrayQueue() for i in range(10): queue.add(i) stack = queue_to_stack(queue) print(queue) print(stack) print(stack.pop()) print(queue.pop()) stack.add(11) queue.add(11) print(queue) print(stack)
class TicketCounterSimulation(): # Create a simulation object. def __init__(self, numAgents, numMinutes, betweenTime, serviceTime): # Parameters supplied by the user. self._arriveProb = 1.0 / betweenTime self._serviceTime = serviceTime self._numMinutes = numMinutes # Simulation components. self._passengerQ = ArrayQueue() self._theAgents = Array(numAgents) for i in range(numAgents): self._theAgents[i] = TicketAgent(i + 1) # Computed during the simulation. self._totalWaitTime = 0 self._numPassengers = 0 # Run the simulation using the parameters supplied earlier. def run(self): for curTime in range(self._numMinutes + 1): self._handleArrive(curTime) self._handleBeginService(curTime) self._handleEndService(curTime) # Print the simulation results. def printResults(self): numServed = self._numPassengers - len(self._passengerQ) avgWait = float(self._totalWaitTime) / numServed print("") print("Number of passengers served = ", numServed) print("Number of passengers remaining in line = %d" % len(self._passengerQ)) print("The average wait time was %4.2f minutes." % avgWait) # Handles simulation rule #1. def _handleArrive(self, curTime): """ Rule 1: If a customer arrives, he is added to the queue. At most, one customer can arrive during each time step. """ if random.random() <= self._arriveProb: self._numPassengers += 1 thePassenger = Passenger(self._numPassengers, curTime) print("Time {}: Passenger {} arrived.".format( curTime, self._numPassengers)) self._passengerQ.add(thePassenger) # Handles simulation rule #2. def _handleBeginService(self, curTime): """ Rule 2: If there are customers waiting, for each free server, the next customer in line begins her transaction. """ for agent in self._theAgents: if agent.isFree(): if not self._passengerQ.isEmpty(): thePassenger = self._passengerQ.pop() agent.startService(thePassenger, curTime + self._serviceTime) print("Time {}: Agent {} started serving passenger {}.". format(curTime, agent._idNum, thePassenger._idNum)) # Handles simulation rule #3. def _handleEndService(self, curTime): """ Rule 3: For each server handling a transaction, if the transaction is complete, the customer departs and the server becomes free. """ for agent in self._theAgents: if agent.isFinished(curTime): thePassenger = agent.stopService() self._totalWaitTime += curTime - thePassenger._arrivalTime - self._serviceTime print("Time {}: Agent {} stopped serving passenger {}.".format( curTime, agent._idNum, thePassenger._idNum))
import unittest from arrayqueue import ArrayQueue p = ArrayQueue() for i in range(7): p.add(i + 1) q = ArrayQueue() for i in range(12): q.add(i + 1) r = ArrayQueue() for i in range(7): r.add(i + 1) s = ArrayQueue() for i in range(3): s.add(i + 1) t = ArrayQueue() for i in range(1): t.add(i + 1) class UnitTests(unittest.TestCase): def add1_unit_test(self): expected = [1, 2, 3, 4, 5, 6, 7] self.assertEqual(str(expected), str(p)) def add2_unit_test(self): expected = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]