def simulation(): person_queue = Queue() for i in xrange(10): person_queue.enqueue(Person(0)) waiting_list = [] elevators = [] for i in xrange(6): elevators.append(Elevator()) def new_comer(time): # every seconds comes 1 to 5 person for i in xrange(random.randint(1, 6)): person_queue.enqueue(Person(time)) for sec in xrange(3600): new_comer(sec) for e in elevators: if e.is_available() and not person_queue.is_empty(): e.take(person_queue, sec, waiting_list) e.tick() print "Average waiting time on 1st floor: %f" % \ (sum(waiting_list) / float(len(waiting_list)))
def collection(self, node: Node, pre: str, q: Queue): if not node: return if node.value: q.en_queue(node.value) # 遍历子节点 for i in range(node.R): self.collection(node.next[i], pre + chr(i), q)
def find_escape_position(total, count): q = Queue() for i in xrange(total): q.enqueue(i+1) while q.size() > 1: for i in xrange(count-1): item = q.dequeue() q.enqueue(item) q.dequeue() return q.dequeue()
def test_on_case_from_hw2_task(): queue = Queue() queue.push(2) queue.push(4) queue.push(6) queue.push(8) queue.push(0) assert queue.pop() == 2
class TestQueue(unittest.TestCase): def setUp(self): self.queue = Queue() def enqueue_test_values(self): self.queue.enqueue(1) self.queue.enqueue(2) self.queue.enqueue(3) def test_initializer(self): self.assertEqual(self.queue.linked_list.node_count, 0) def test_enqueue(self): self.enqueue_test_values() self.assertEqual(self.queue.linked_list.node_count, 3) def test_dequeue(self): self.enqueue_test_values() self.assertEqual(self.queue.dequeue().value, 1) self.assertEqual(self.queue.dequeue().value, 2) self.assertEqual(self.queue.dequeue().value, 3) def test_node_at_index(self): self.enqueue_test_values() self.assertEqual(self.queue.linked_list.node_at_index(1).value, 2) def test_is_empty(self): self.assertTrue(self.queue.is_empty()) self.enqueue_test_values() self.assertFalse(self.queue.is_empty())
def traversal_level_order(self): # o(n) for time # o(n) for space if self.root is None: return node_queue = Queue() node_queue.queue(self.root) value = [] while not node_queue.is_empty(): current_node = node_queue.de_queue() value.append(current_node.value) if current_node.left is not None: node_queue.queue(current_node.left) if current_node.right is not None: node_queue.queue(current_node.right) return value
def test_push(): queue = Queue() queue.push(1) assert queue.front() == 1 assert queue.size == 1 queue.push(2) assert queue.front() == 1 assert queue.size == 2
class DogCatQueue(object): def __init__(self): self.content = Queue() self.length_of_dog = 0 self.length_of_cat = 0 self.length_of_queue = 0 def add(self, data): self.content.add(data) if data.get_pet_type == 'cat': self.length_of_cat += 1 elif data.get_pet_type == 'dog': self.length_of_dog += 1 self.length_of_queue += 1 def poll_all(self): return self.poll_all() def _poll_what(self, what): for _ in range(self.length_of_queue): out = self.content.poll() if out.get_pet_type == what: yield out else: self.add(out) def poll_dog(self): self._poll_what('dog') def poll_cat(self): self._poll_what('cat') def is_empty(self): return self.length_of_queue == 0 def is_dog_empty(self): return self.length_of_dog == 0 def is_cat_empty(self): return self.length_of_cat == 0
def bfs_iter(self, grp, src): vtx = [0] * len(grp) que = Queue() vtx[src] = 1 que.push(src) while len(que) > 0: i = que.pop() assert (vtx[i] == 1) for j in grp[i]: if vtx[j] == 0: vtx[j] = 1 que.push(j) return vtx
def get_max_values_of_list(data_list, window_length): q = Queue() res = [] for index, data in enumerate(data_list): put_queue(q, index, data_list) if q.peek() == index - window_length: q.poll() if index >= window_length - 1: res.append(data_list[q.peek()]) return res
def main_bfs(self, grp, src): vtx = [0] * len(grp) dpt = [None] * len(grp) que = Queue() vtx[src] = 1 dpt[src] = 0 que.push(src) while len(que) > 0: i = que.pop() assert (vtx[i] == 1) for j in grp[i]: # 只有首次遍历到的深度才是最小深度 if vtx[j] == 0: vtx[j] = 1 dpt[j] = dpt[i] + 1 que.push(j) return dpt
def simulation(numSeconds, pagesPerMinute): labprinter = Printer(pagesPerMinute) printQueue = Queue() waitingtimes = [] for currentSecond in range(numSeconds): if newPrintTask(): task = Task(currentSecond) printQueue.enqueue(task) if (not labprinter.busy()) and (not printQueue.is_empty()): nexttask = printQueue.dequeue() waitingtimes.append(nexttask.waitTime(currentSecond)) labprinter.startNext(nexttask) labprinter.tick() averageWait = sum(waitingtimes) / len(waitingtimes) print("Finished tasks %3d Average Wait %6.2f secs %3d tasks remaining." % (len(waitingtimes), averageWait, printQueue.size()))
def test_queue(self): queue = Queue() self.assertEqual(queue.is_empty(), True) self.assertEqual(queue.peek(), None) queue.queue("first_in_line") self.assertEqual(queue.peek(), "first_in_line") self.assertEqual(queue.is_empty(), False) queue.queue("second_in_line") self.assertEqual(queue.de_queue(), "first_in_line") self.assertEqual(queue.peek(), "second_in_line") self.assertEqual(queue.de_queue(), "second_in_line") self.assertEqual(queue.is_empty(), True) self.assertEqual(queue.peek(), None)
def setUp(self): self.queue = Queue()
def get_num(arr, num): if arr is None or len(arr) == 0: return qmin = Queue() qmax = Queue() start = 0 end = 0 res = 0 length = len(arr) while start < length: while end < length: while (not qmax.is_empty()) and arr[qmax.peek()] <= arr[end]: qmax.poll() qmax.add(end) while (not qmin.is_empty()) and arr[qmin.peek()] >= arr[end]: qmin.poll() qmin.add(end) if arr[qmax.peek()] - arr[qmin.peek()] > num: break end += 1 print(start, end - 1) res += end - start if qmax.peek() == start: qmax.poll() if qmin.peek() == start: qmin.poll() start += 1 return res
else: winner = self.player_2 return winner def is_game_of(self): if (self.player_1.size == 0 or self.player_2.size == 0 or self.steps == 10**6): return True else: return False if __name__== "__main__": player_1 = Queue() player_2 = Queue() # Раздача карт 1 игроку inp_player_1 = input()[:9] for cart in inp_player_1.split(" "): cart = int(cart) player_1.push(cart) # Раздача карт 2 игроку inp_player_2 = input()[:9] for cart in inp_player_2.split(" "): cart = int(cart) player_2.push(cart) game = Game(player_1, player_2) # процесс игры
def main(self, chst): assert (isinstance(chst, dict) and len(chst) > 2) # makes sense # build Huffman tree hp = MinBinaryHeap(map(lambda (c, f): self.__class__.Node(f, c), chst.items()), lambda x: x.key) while len(hp) > 1: left = hp.pop() right = hp.pop() node = self.__class__.Node(left.key + right.key, None, left, right) hp.push(node) # check tree and prepare for code generation assert (len(hp) == 1) node = hp.pop() assert (node.key == sum(map(lambda x: x[1], chst.items())) and node.value is None) node.key = None # generate Huffman code by traversing Huffman tree que = Queue() que.push(node) while len(que) > 0: node = que.pop() if node.value is not None: assert (isinstance(node.key, str) and isinstance(node.value, str)) chst[node.value] = node.key assert (node.left is None and node.right is None) elif node.key is None: # node is root if node.left: node.left.key = '0' que.push(node.left) if node.right: node.right.key = '1' que.push(node.right) else: assert (isinstance(node.key, str)) if node.left: node.left.key = node.key + '0' que.push(node.left) if node.right: node.right.key = node.key + '1' que.push(node.right) return chst
def test_front(): queue = Queue() queue.push(1) assert queue.front() == 1 assert queue.size == 1 queue.push(2) queue.push(3) assert queue.front() == 1 assert queue.size == 3 for i in range(4, 100): queue.push(i) assert queue.front() == 1
def main(): data = [x for x in range(4)] q = Queue() q.add_all(data) print(q)
def __init__(self): self.content = Queue() self.length_of_dog = 0 self.length_of_cat = 0 self.length_of_queue = 0
def main_bfs_iter(self, grp): num = 0 for i in range(len(grp)): for j in range(len(grp[0])): if grp[i][j] == 1: num += 1 que = Queue() que.push((i, j)) while len(que) > 0: a, b = que.pop() if 0 <= a < len(grp) and 0 <= b < len(grp[0]) and grp[a][b] == 1: grp[a][b] = 0 que.push((a, b + 1)) que.push((a + 1, b + 1)) que.push((a + 1, b)) que.push((a + 1, b - 1)) return num
def test_queue(self): q = Queue() self.assertEqual(True, q.is_empty()) self.assertEqual(0, q.size()) q.enqueue(1) self.assertEqual(False, q.is_empty()) self.assertEqual(1, q.size()) q.enqueue(True) q.enqueue("Hello, World") self.assertEqual(3, q.size()) self.assertEqual(1, q.dequeue()) self.assertEqual(True, q.dequeue()) self.assertEqual(1, q.size()) q.dequeue() self.assertEqual(True, q.is_empty())
def find_escape_position(total, count): q = Queue() for i in xrange(total): q.enqueue(i + 1) while q.size() > 1: for i in xrange(count - 1): item = q.dequeue() q.enqueue(item) q.dequeue() return q.dequeue()
def main_bfs_iter(self, grp): num = 0 for i in range(len(grp)): for j in range(len(grp[0])): if grp[i][j] == 1: num += 1 que = Queue() que.push((i, j)) while len(que) > 0: a, b = que.pop() if 0 <= a < len(grp) and 0 <= b < len( grp[0]) and grp[a][b] == 1: grp[a][b] = 0 que.push((a, b + 1)) que.push((a + 1, b + 1)) que.push((a + 1, b)) que.push((a + 1, b - 1)) return num
def test_pop(): queue = Queue() queue.push(1) assert queue.pop() == 1 assert queue.size == 0 queue.push(2) assert queue.front() == 2 assert queue.size == 1 queue.push(3) queue.push(4) assert queue.pop() == 2 assert queue.size == 2 assert queue.pop() == 3 assert queue.pop() == 4 assert queue.size == 0