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()
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
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)
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
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)
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
