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)