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