def queue_to_stack(queue):
"""
Converts the queue to a stack.
"""
stk_ar = ArrayStack()
q = ArrayQueue(queue)
el = []
while not q.isEmpty():
el.append(q.pop())
q1 = ArrayQueue(el[::-1])
while not q1.isEmpty():
stk_ar.push(q1.pop())
return stk_ar
def reverse_queue(queue: ArrayQueue) -> ArrayQueue:
"""
Return reversed queue. (Destructive! Clear queue).
"""
if len(queue) <= 1:
return queue
element = queue.pop()
reversed_queue = reverse_queue(queue)
reversed_queue.add(element)
return reversed_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):
"""
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 queue_to_stack(queue):
"""
converts queue to a stack
"""
queue_copy = ArrayQueue(queue)
stack = ArrayStack()
while True:
try:
element = queue_copy.pop()
stack.push(element)
except KeyError:
break
stack_reversed = ArrayStack()
while True:
try:
element = stack.pop()
stack_reversed.push(element)
except KeyError:
break
return stack_reversed
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()
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))
# 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)
