def test_dequeuing_from_queue_removes_item():
queue = Queue()
queue.enqueue(1)
assert_equal(queue.empty(), False)
assert_equal(queue.dequeue(), 1)
assert_equal(queue.empty(), True)
def test_items(self):
q = Queue()
q.enqueue('A')
q.enqueue('B')
assert ['A', 'B'] == q.items()
def test_enqueuing_to_queue_adds_item_to_queue():
queue = Queue()
assert_equal(queue.empty(), True)
queue.enqueue(1)
assert_equal(queue.empty(), False)
assert_equal(queue.dequeue(), 1)
def test_dequeuing_from_queue_returns_first_item():
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
assert_equal(queue.dequeue(), 1)
def eliminated(people, skip):
"""Return a list of the positions of people as they are eliminated.
The position of the last person standing is at the end of the list.
Assume people is a positive integer.
Assume skip is a non-negative integer.
For example:
>>> eliminated(3, 0)
[1, 2, 3]
>>> eliminated(3, 1)
[2, 1, 3]
>>> eliminated(3, 4)
[2, 3, 1]
"""
assert people > 0
assert skip >= 0
circle = Queue()
for position in range(1, people + 1):
circle.enqueue(position)
positions = []
while circle:
for _skipped in range(skip):
circle.enqueue(circle.dequeue())
positions.append(circle.dequeue())
return positions
def test_add_item(self):
q = Queue()
q.enqueue('A')
assert len(q) == 1
assert q.head.data == 'A'
assert q.tail.data == 'A'
def test_serialize(self):
q = Queue()
q.enqueue('A')
q.enqueue('B')
items = q.serialize()
assert tuple(['A', 'B']) == items
def del_min(self):
q = Queue()
del self.tree[0][0]
q.enqueue(self.tree[self.power][len(self.tree[self.power]) - 1])
del self.tree[self.power][len(self.tree[self.power]) - 1]
self.tree[0].insert(0, q.dequeue())
return self.tree
def hot_potato(name_list, num):
q = Queue()
for i in range(0, len(name_list)):
q.enqueue(name_list[i])
for j in range(0, len(name_list) - 1):
for k in range(0, num):
q.enqueue(q.dequeue())
q.dequeue()
remaining_person = q.dequeue()
return remaining_person
def test_iteration(self):
q = Queue()
items = ['A', 'B']
for item in items:
q.enqueue(item)
for i, item in enumerate(q):
assert item.data == items[i]
def convert_to_queue(word_list):
'''
Helper function to convert a word_list into a queue
'''
queue = Queue()
for word in word_list:
queue.enqueue(word)
return queue
def test_enqueue_different_sizes(self, lst: list) -> None:
"""
Tests the Queue.enqueue method on queues with different amounts of items.
"""
q = Queue(lst)
new_item = randint(-100, 100)
q.enqueue(new_item)
self.assertEqual(lst + [new_item], q.get_items())
def test_enqueue_empty(self) -> None:
"""
Tests the Queue.enqueue method on empty queues.
"""
n = 0
while n <= 10:
q = Queue()
queue_item = randint(-100, 100)
q.enqueue(queue_item)
self.assertEqual([queue_item], q.get_items())
n += 1
def test_enqueue_size_one(self) -> None:
"""
Tests the Queue.enqueue method on queues with 1 item only.
"""
n = 0
while n <= 10:
initial_item = randint(-1000, 1000)
q = Queue([initial_item])
new_item = randint(-1000, 1000)
q.enqueue(new_item)
self.assertEqual([initial_item, new_item], q.get_items())
n += 1
def test_len(self):
q = Queue()
assert len(q) == 0
q.enqueue('A')
assert len(q) == 1
q.enqueue('B')
assert len(q) == 2
q.dequeue()
assert len(q) == 1
q.dequeue()
assert len(q) == 0
def hot_potato(namelist, num):
q = Queue()
for name in namelist:
q.enqueue(name)
while q.size() > 1:
for i in range(num):
q.enqueue(q.dequeue())
q.dequeue()
return q.dequeue()
def hot_potato(name_list, num):
# Finish the function
q = Queue()
for i in name_list:
q.enqueue(i)
while q.size() > 1:
for _ in range(num):
tmp = q.dequeue()
q.enqueue(tmp)
q.dequeue()
remaining_person = q.dequeue()
return remaining_person
def bfs(g, start):
start.setDistance(0)
start.setPred(None)
vertQueue = Queue()
vertQueue.enqueue(start)
while (vertQueue.size() > 0):
currentVert = vertQueue.dequeue()
for nbr in currentVert.getConnections():
if (nbr.getColor() == 'white'):
nbr.setColor('gray')
nbr.setDistance(currentVert.getDistance() + 1)
nbr.setPred(currentVert)
vertQueue.enqueue(nbr)
currentVert.setColor('black')
def test_clear(self):
q = Queue()
q.enqueue('A')
assert len(q) == 1
assert q.head is not None
assert q.tail is not None
q.clear()
assert len(q) == 0
assert q.head is None
assert q.tail is None
def hot_potato(name_list, num):
q = Queue()
for name in name_list:
q.enqueue(name)
while q.size() > 1:
for j in range(num):
person = q.dequeue()
q.enqueue(person)
q.dequeue()
remaining_person = q.dequeue()
return remaining_person
def test_dequeue(self):
q = Queue()
q.enqueue('A')
assert len(q) == 1
assert q.head.data == 'A'
assert q.tail.data == 'A'
q.enqueue('B')
assert len(q) == 2
assert q.head.data == 'A'
assert q.tail.data == 'B'
q.dequeue()
assert len(q) == 1
assert q.head.data == 'B'
assert q.tail.data == 'B'
def base_converter(dec, base):
digits = "0123456789ABCDEF"
i = 0
for j in range(10000):
if(dec // (base**j) == 0):
i = j
break
q = Queue()
for k in range(i):
k = i - k
temp = dec % (base ** k) // (base ** (k-1))
q.enqueue(digits[temp])
str_temp = ""
for l in range(i):
str_temp += str(q.dequeue())
return str_temp
def hot_potato(name_list, num):
number=len(name_list)
peoplelist=Queue()
for i in range(number):
peoplelist.enqueue(name_list[i])
while number>1:
for i in range(num):
front=peoplelist.dequeue()
peoplelist.enqueue(front)
peoplelist.dequeue()
number-=1
remaining_person=peoplelist.dequeue()
return remaining_person
def hot_potato(name_list, num):
q = Queue()
for i in range(len(name_list)):
q.enqueue(name_list[i])
while num > 0 :
if q.size() > 1:
for i in range(num):
q.enqueue(q.dequeue())
q.dequeue()
if q.size() == 1:
remaining_person = q.dequeue()
break
return remaining_person
def find_bfs(self, data):
queue = Queue()
queue.enqueue(self.root)
while not queue.empty:
next_ = queue.dequeue()
if next_:
queue.enqueue(next_.left)
queue.enqueue(next_.right)
if next_.data == data:
return next_
class TestQueue(unittest.TestCase):
def setUp(self):
# Create queues for the tests to use
self.new = Queue()
self.empty = Queue()
self.empty.enqueue('hi')
self.empty.dequeue()
# Don't add in ascending or descending order
self.non_empty = Queue()
self.non_empty.enqueue(5)
self.non_empty.enqueue(2)
self.non_empty.enqueue(7)
self.non_empty.enqueue(2)
def test_length(self):
self.assertEqual(len(self.new), 0)
self.assertEqual(len(self.empty), 0)
self.assertEqual(len(self.non_empty), 4)
def test_is_empty(self):
self.assertTrue(self.new.is_empty())
self.assertTrue(self.empty.is_empty())
self.assertFalse(self.non_empty.is_empty())
def test_fifo_order(self):
self.assertEqual(self.non_empty.dequeue(), 5)
self.assertEqual(self.non_empty.dequeue(), 2)
self.assertEqual(self.non_empty.dequeue(), 7)
self.assertEqual(self.non_empty.dequeue(), 2)
def test_access_to_empty(self):
with self.assertRaises(AssertionError):
self.new.front()
with self.assertRaises(AssertionError):
self.empty.front()
with self.assertRaises(AssertionError):
self.new.dequeue()
with self.assertRaises(AssertionError):
self.empty.dequeue()
def test_membership(self):
self.assertFalse(2 in self.new)
self.assertFalse(2 in self.empty)
self.assertTrue(2 in self.non_empty)
self.assertTrue(5 in self.non_empty)
self.assertTrue(7 in self.non_empty)
def initialize(self):
q = Queue()
for i in range(self.power, 0, -1):
for j in range(0, 2**(i - 1)):
try:
self.tree[i][2 * j + 1]
self.tree[i - 1][j]
except IndexError:
try:
self.tree[i][2 * j]
self.tree[i - 1][j]
except IndexError:
continue
else:
if self.tree[i][2 * j] < self.tree[i - 1][j]:
q.enqueue(self.tree[i][2 * j])
del self.tree[i][2 * j]
q.enqueue(self.tree[i - 1][j])
del self.tree[i - 1][j]
self.tree[i - 1].insert(j, q.dequeue())
self.tree[i].insert(2 * j, q.dequeue())
else:
for k in range(0, self.power - i + 1):
try:
self.tree[i + k][2 * j + 1]
except IndexError:
try:
self.tree[i + k][2 * j]
except IndexError:
break
else:
if self.tree[i + k][2 * j] < self.tree[i + k -
1][j]:
q.enqueue(self.tree[i + k][2 * j])
del self.tree[i + k][2 * j]
q.enqueue(self.tree[i + k - 1][j])
del self.tree[i + k - 1][j]
self.tree[i + k - 1].insert(j, q.dequeue())
self.tree[i + k].insert(2 * j, q.dequeue())
else:
if self.tree[i + k][2 * j + 1] < self.tree[
i + k - 1][j] and self.tree[i][
2 * j + 1] < self.tree[i][2 * j]:
q.enqueue(self.tree[i + k][2 * j + 1])
del self.tree[i + k][2 * j + 1]
q.enqueue(self.tree[i + k - 1][j])
del self.tree[i + k - 1][j]
self.tree[i + k - 1].insert(j, q.dequeue())
self.tree[i + k].insert(2 * j + 1, q.dequeue())
j = 2 * j + 1
elif self.tree[i + k][2 * j] < self.tree[i + k -
1][j]:
q.enqueue(self.tree[i + k][2 * j])
del self.tree[i + k][2 * j]
q.enqueue(self.tree[i + k - 1][j])
del self.tree[i + k - 1][j]
self.tree[i + k - 1].insert(j, q.dequeue())
self.tree[i + k].insert(2 * j, q.dequeue())
j = 2 * j
return self.tree
class Markov(dict):
def __init__(self, word_list, order=2, sentences=1):
super().__init__()
self.order = order # order of the markov chain
self.sentences = sentences
self.memory = Queue(order) # for sampling from markov model
if word_list is not None:
self['START'] = Dictogram()
self._create_chain(word_list)
def _create_chain(self, word_list):
"""Generate the internal markov chain that will be used by the sentence generator."""
for i, message in enumerate(word_list + word_list[:self.order]):
if i < self.order: # to fill the queue initally so that we do not add states that are smaller than order
self.memory.enqueue(message) # enqueue each new item
else:
current_state = self.memory.serialize() # the current state
self.memory.enqueue(message) # create the new state
new_state = self.memory.serialize() # the next state
# TODO: improve how I want to sample start tokens
if re.match('[A-Z]', current_state[0]) is not None:
# TODO: Don't add start tokens
self['START'].add_count(current_state)
if current_state in self: # check to see if the state already exists
# if it does just add the next state to it
self[current_state].add_count(message)
else:
# otherwise create a new dictogram with the new state
self[current_state] = Dictogram([message])
self.memory.clear()
def generate_sentence(self):
"""Generate a sentence from the internal markov chain."""
sentences = [
] # empty list to keep generated sentences so that we can return them :)
for _ in range(self.sentences
): # generate as many sentences as the user wants
# word from starting state
starting_state = self['START'].sample()[0]
sentence_list = list() # empty array to append sentence items to
# the start of the sentence :)
sentence_list.extend(starting_state)
# Count to keep as a failsafe if there is no punctuation.
failsafe = 0
# loop through starting state and add those items to the queue
for item in starting_state:
self.memory.enqueue(item)
while True:
# increase failsafe for each iteration
failsafe += 1
# get the next state by samplying the current state
next_state = self[starting_state].sample()[0] # a word
# enque the word into 'memory'
self.memory.enqueue(next_state)
# add the item to the list
sentence_list.append(next_state)
# check if the word is an end token
if re.search('[\.\?\!]', next_state) is not None:
# clear the memory
self.memory.clear()
# return the sentence as a string without a period because it is added from stop token
sentences.append(' '.join(sentence_list))
break
# set the new 'starting' state to the the tuple that is currently in 'memory'
starting_state = self.memory.serialize()
# if ran 20 times return what we already have and add a period
if failsafe > 20:
# clear memory for next sentence generation
self.memory.clear()
# return the sentence as a string with an appended period because it will not have from stop token
sentences.append(' '.join(sentence_list) + '.')
break
return ' '.join(sentences)
def test_empty_returning_false_when_not_empty():
queue = Queue()
queue.enqueue(1)
assert_equal(queue.empty(), False)
