class QStack:
def __init__(self):
self.data = ArrayQueue()
def __len__(self):
return len(self.data)
def is_empty(self):
return len(self) == 0
def push(self, elem): #O(1)
self.data.enqueue(elem)
def pop(self): #O(n)
if self.is_empty():
raise Exception("The QStack is empty")
helper = ArrayQueue()
for i in range(len(self) - 1):
helper.enqueue(self.data.dequeue())
val = self.data.dequeue()
self.data = helper
return val
def top(self): #O(n)
if self.is_empty():
raise Exception("The QStack is empty")
helper = ArrayQueue()
for i in range(len(self)):
val = self.data.dequeue()
helper.enqueue(val)
self.data = helper
return val
def breadth_first_print(self):
Q = ArrayQueue()
Q.enqueue(self.root())
while not Q.is_empty():
p = Q.dequeue()
print(p)
for c in self.children(p):
Q.enqueue(c)
def breath_first(self):
from ArrayQueue import ArrayQueue
fringe = ArrayQueue()
fringe.enqueue(self.root())
while not fringe.is_empty():
p = fringe.dequeue()
yield p
for c in p.children():
fringe.enqueue(c)
def permutations(lst):
stack = ArrayStack()
queue = ArrayQueue()
for val in lst:
queue.enqueue([val])
while (len(lst) != len(queue.first())):
for integer in lst:
if integer not in queue.first():
stack.push([integer])
for i in range(len(stack)):
queue.enqueue(queue.first() + stack.pop())
queue.dequeue()
while queue.is_empty == False:
permuations_array.append(q.dequeue())
return permuations_array
def n_bonacci(n, k):
numQueue = ArrayQueue()
numOfVals = 0
for i in range(n):
if numOfVals == k:
return
numQueue.enqueue(1)
numOfVals += 1
yield 1
while numOfVals < k:
nextVal = 0
for i in range(len(numQueue)):
nextVal += numQueue.first()
numQueue.enqueue(numQueue.dequeue())
numQueue.dequeue()
numQueue.enqueue(nextVal)
yield nextVal
numOfVals += 1
def print_tree(self):
q = ArrayQueue()
q.enqueue(self.root)
while not q.empty():
n = q.dequeue()
print('[k: ' + str(n.key) + ', v: ' + str(n.value) + ']')
if n.left is not None:
q.enqueue(n.left)
if n.right is not None:
q.enqueue(n.right)
def breadth_first(self):
if (self.is_empty()):
return
line = ArrayQueue()
line.enqueue(self.root)
while (line.is_empty() == False):
curr_node = line.dequeue()
yield curr_node
if (curr_node.left is not None):
line.enqueue(curr_node.left)
if (curr_node.right is not None):
line.enqueue(curr_node.right)
def invert_binary_tree2(root):
if (root is None):
return
line = ArrayQueue()
line.enqueue(root)
while (line.is_empty() == False):
curr_node = line.dequeue()
curr_node.left, curr_node.right \
= curr_node.right, curr_node.left
if (curr_node.left is not None):
line.enqueue(curr_node.left)
if (curr_node.right is not None):
line.enqueue(curr_node.right)
class Company:
def __init__(self):
self._actions = ArrayQueue()
def buy(self, quantity, price):
self._actions.enqueue(Sale(quantity, price))
def sell(self, quantity, price):
gain = 0
while quantity > 0:
latest = self._actions.first()
if latest.qua <= quantity:
gain += latest.qua * (price - latest.price)
quantity -= latest.qua
self._actions.dequeue()
else:
gain += quantity * (price - latest.price)
latest.qua -= quantity
quantity = 0
return gain
def __str__(self):
return str(self._actions._data)
def __str__(self):
str_return = ''
q_uttt = ArrayQueue()
q_uttt.enqueue(self._root)
last_depth = 0
while not q_uttt.is_empty():
child = q_uttt.dequeue()
if last_depth != child.get_depth():
str_return += "\n"
str_return += child.get_meta().get_meta_int() + ' '
last_depth = child.get_depth()
for grand_child in child.get_children():
q_uttt.enqueue(grand_child)
return str_return
class MeanQueue:
def __init__(self):
self.data = ArrayQueue()
def __len__(self):
return len(self.data)
def is_empty(self):
return len(self.data) == 0
def enqueue(self, e):
if not isinstance(e, (int, float)):
raise TypeError("Item must be int or float type!")
self.data.enqueue(e)
def dequeue(self):
if self.is_empty():
raise Exception("MeanQueue is empty!")
return self.data.dequeue()
def first(self):
if self.is_empty():
raise Exception("MeanQueue is empty!")
return self.data.first()
def sum(self):
total = 0
for i in range(len(self)):
total += self.data.first()
self.data.enqueue(self.data.dequeue())
return total
def mean(self):
return self.sum() / len(self)
class QueueStack:
def __init__(self):
self.data = ArrayQueue()
def __len__(self):
return len(self.data)
def is_empty(self):
return len(self) == 0
def push(self, e):
self.data.enqueue(e)
def pop(self):
for i in range(len(self) - 1):
self.data.enqueue(self.data.dequeue())
return self.data.dequeue()
def top(self):
for i in range(len(self) - 1):
self.data.enqueue(self.data.dequeue())
val = self.data.first()
self.data.enqueue(self.data.dequeue())
return val
def permutations(lst):
perms = ArrayStack()
parts = ArrayQueue()
combo = []
for x in range(len(lst)):
if perms.is_empty():
perms.push([lst[x]])
else:
for y in range(len(perms)):
p_lst = perms.pop()
for z in range(len(p_lst) + 1):
parts.enqueue(p_lst[:z] + [lst[x]] + p_lst[z:])
for a in range(len(parts)):
perms.push(parts.dequeue())
while not perms.is_empty():
combo.append(perms.pop())
return combo
class CheckoutManager(object):
"""CheckoutManager object for handling a collection of checkout queues that process customers.'"""
def __init__(self, n_checkouts, checkout_capacity, staging_capacity):
self.checkouts = [ArrayQueue(checkout_capacity) for _ in xrange(n_checkouts)]
self.staging_queue = ArrayQueue(staging_capacity)
self.finished_customers = []
def enqueue_random(self, customer):
"""Adds the given customer to a random checkout."""
checkout = random.choice(self.checkouts)
customer.queue(checkout)
def enqueue_shortest(self, customer):
"""Adds the given customer to the checkout with the shortest queue."""
checkout = min(self.checkouts, key=len)
customer.queue(checkout)
def enqueue_staging(self, customer):
"""Adds the customer to a staging queue. The customer will move from the staging queue to an empty checkout as
one becomes available."""
customer.queue(self.staging_queue)
def has_item(self):
"""Checks if any checkout has a customer in it, or if the staging queue has a customer in it."""
for checkout in self.checkouts:
if checkout.has_item():
return True
return False
def update(self):
"""Called once per game cycle."""
for checkout in self.checkouts:
if checkout.has_item():
if checkout[0].checked_out(): # remove finished customer
customer = checkout.dequeue()
customer.leave()
if checkout.empty() and self.staging_queue.has_item(): # add waiting customer
customer = self.staging_queue.dequeue()
customer.queue(checkout)
if checkout.has_item():
checkout[0].checkout() # checkout front customer
def is_complete(root):
if (root is None):
return True
line = ArrayQueue()
line.enqueue(root)
level = 0
while (line.is_empty() == False):
if (len(line) != 2**level):
return False
for i in range(2**level):
curr_node = line.dequeue()
if (curr_node.left is not None):
line.enqueue(curr_node.left)
if (curr_node.right is not None):
line.enqueue(curr_node.right)
level += 1
return True
def print_tree_level(bin_Tree, level):
output = []
if (bin_Tree.is_empty()):
return
line = ArrayQueue()
line.enqueue((bin_Tree.root, 0))
while (line.is_empty() == False):
curr = line.dequeue()
output.append(curr)
depth = curr[1]
if (curr[0].left is not None):
line.enqueue((curr[0].left, depth + 1))
if (curr[0].right is not None):
line.enqueue((curr[0].right, depth + 1))
i = 0
outputlst = []
for i in output:
if i[1] == level:
outputlst.append(i[0].data)
print(outputlst)
if __name__ == '__main__':
q = ArrayQueue()
print("Is queue empty: ")
if q.empty():
print("yes")
else:
print("no")
print("Enqueueing 9...")
q.enqueue(9)
print("Is queue empty: ")
if q.empty():
print("yes")
else:
print("no")
print("Dequeueing... ")
print(q.dequeue())
print("Enqueueing 45, 53, and 85...")
q.enqueue(45)
q.enqueue(53)
q.enqueue(85)
print("Now dequeueing all of them...")
print(q.dequeue())
print(q.dequeue())
print(q.dequeue())
print("Is queue empty: ")
if q.empty():
print("yes")
else:
print("no")
"""
3 Suppose you have a deque D containing the numbers (1,2,3,4,5,6,7,8),
in this order. Suppose further that you have an initially empty queue Q.
Give a code fragment that uses only D and Q (and no other variables) and
results in D storing the elements in the order (1,2,3,5,4,6,7,8).\
"""
from collections import deque
from ArrayQueue import ArrayQueue
d = deque(list(range(10)))
q = ArrayQueue()
for _ in range(len(d)):
q.enqueue(d.pop())
for _ in range(len(q)):
d.append(q.dequeue())
print(d)
if __name__ == "__main__":
D = ArrayDeque()
Q = ArrayQueue()
for i in range(1, 9):
D.add_last(i)
# step 1
for _ in range(3):
Q.enqueue(D.delete_last())
# step 2
for _ in range(2):
D.add_first(D.delete_last())
# step 3
for _ in range(3):
Q.enqueue(D.delete_last())
# step 4
D.add_first(D.delete_last())
# step 5
for _ in range(3):
D.add_first(Q.dequeue())
# step 6
for _ in range(3):
D.add_last(D.delete_first())
# step 7
for _ in range(3):
D.add_first(Q.dequeue())
# check result
for i in range(8):
print(D.delete_first())
block_lst = []
job_is_running_time = 0 # to calc cpu utilization
job_is_blocking_time = 0 # to calc i/o utilization
if detailed_mode:
print(
"\nThis detailed printout gives the state and remaining burst for each process.\n"
)
while job_incomplete > 0:
# one time unit is one cycle
if detailed_mode:
cycle_report(time, jobs_lst)
# scan status for change
scan_job(Q, jobs_lst, time)
if not Q.is_empty() and cpu_can_run:
cur_job = Q.dequeue()
cur_job.start_run()
job_running_in_cur_cycle = False
job_is_blocking_in_cur_cycle = False
for j in jobs_lst:
if j.get_state() == 'running':
j.run_controller()
job_running_in_cur_cycle = True
elif j.get_state() == 'blocked':
j.block_controller()
job_is_blocking_in_cur_cycle = True
elif j.get_state() == 'ready':
j.increment_waiting_time()
if job_running_in_cur_cycle:
class TestArrayQueue(unittest.TestCase):
def setUp(self):
self.q = ArrayQueue()
self.q.enqueue(1)
self.q.enqueue(2)
self.q.enqueue(3)
def test_instantiation(self):
print('Can create an instance')
self.assertIsInstance(self.q, ArrayQueue)
def test_length_checking(self):
print('Can check the length of the queue')
self.assertEqual(len(self.q), 3)
def test_first_method(self):
print('Can return the first element of the queue')
self.assertEqual(self.q.first(), 1)
def test_enqueue_method(self):
print('Can add elements to the queue')
self.q.enqueue(4)
self.q.enqueue(5)
self.assertEqual(len(self.q), 5)
self.assertEqual(self.q.first(), 1)
def test_dequeue_method(self):
print('Can remove elements from the front of the queue')
self.q.enqueue(4)
self.q.enqueue(5)
self.q.dequeue()
self.assertEqual(self.q.dequeue(), 2)
self.assertEqual(len(self.q), 3)
self.assertEqual(self.q.first(), 3)
def test_is_empty_method(self):
print('Can check if the queue is empty')
self.q.dequeue()
self.q.dequeue()
self.q.dequeue()
self.assertEqual(self.q.is_empty(), True)
def test_exception_raising(self):
print(
'Can raise exception while performing action(s) on an empty queue')
self.q.dequeue()
self.q.dequeue()
self.q.dequeue()
with self.assertRaises(Empty):
self.q.first()
self.q.dequeue()
