def remove_batch(queue, year): """ ------------------------------------------------------- Description: Remove students enrolled in given year from a given queue Function process queue items sequentially: if year does not match, item is moved to rear of queue students removed are stored in a queue Use: batch_queue = remove_batch(queue,year) ------------------------------------------------------- Parameters: queue - a queue object containing student objects (Queue) year - enrollment year (int) Returns: batch_queue - a queue containing students of same batch ------------------------------------------------------- """ batch_queue = Queue() if isinstance(year, int): for _ in range(len(queue)): student = deepcopy(queue.remove()) student_key = student.key() if str(year) in student_key: batch_queue.insert(student) else: queue.insert(student) else: print('Error(remove_batch): invalid input parameter type') return batch_queue
def test_enqueue(): queue = Queue() queue.enqueue(1) queue.enqueue(2) assert queue.head.value == 2 assert queue.tail.value == 1
def hot_potato(name_list, num): simqueue = Queue() for name in name_list: simqueue.enqueue(name) while simqueue.size > 1: for _ in range(num - 1): simqueue.enqueue(simqueue.dequeue()) simqueue.dequeue() return simqueue.dequeue()
def pop(self, pop_type=None): new_stack = Queue() while self.__stack.size() > 0: current_value = self.__stack.pop() if self.__stack.size() == 0: if pop_type is not None: new_stack.push(current_value) self.__stack = new_stack return current_value new_stack.push(current_value)
def test_get_size(): queue = Queue() assert queue.get_size() == 0 queue.enqueue(1) assert queue.get_size() == 1 queue.dequeue() assert queue.get_size() == 0
def queue_reverser(queue): new_queue = Queue() stack = Stack() length = queue.length for _ in range(length): item = queue.dequeue() stack.push(item) queue.enqueue(item) for _ in range(length): new_queue.enqueue(stack.pop()) return new_queue
def test_dequeue(): queue = Queue() queue.enqueue(1) queue.enqueue(2) queue.enqueue(3) assert queue.dequeue() == 1 assert queue.head.value == 3 assert queue.tail.value == 2 queue.dequeue() assert queue.dequeue() == 3 assert queue.head is None assert queue.tail is None
def transform_bfs(start, target, h, t, flag): q = Queue() q.push(Word(start, True)) counter = 0 while not q.is_empty() and counter <= t: word = q.pop() options = generate_options(word.str) for opt in options: if opt in h: for candidate in h[opt]: if candidate.visited != flag: if candidate.visited == False: if compare(candidate.str, target) == 1: return word.ancestry + [ word.str, candidate.str, target ] else: candidate.visited = flag candidate.ancestry = word.ancestry + [word.str] q.push(candidate) counter += 1 else: return word.ancestry + [ word.str, candidate.str ] + candidate.ancestry[::-1] return None
def __init__(self, height=30, length=30): self.height = height self.length = length self.grid = [] self.grew = False self.head = Snake_Node(0, 0) # Re-used snake node to keep location of food on grid self.food_location = Snake_Node(0, 0) # The tail is a queue of snake nodes self.tail = Queue() self.isdead = False self.create_grid() self.snake_head_start_location() self.spawn_food()
def levelorder(self): items = [] queue = Queue() node = self._root # starting from the root queue.insert(node) # insert it while not queue.is_empty(): node = queue.remove() # pick that node items.append(node._data) # add to the list # if the left side is not None, there exist a left side, add the queue (going left to right_ if node._left is not None: queue.insert(node._left) # you also want to add the right side if node._right is not None: queue.insert(node._right) return items
def test_has_limit(): queue = Queue(1) assert queue.has_space() is True assert queue.limit == 1 queue.enqueue(1) assert queue.has_space() is False with pytest.raises(QueueIsFull): queue.enqueue(2)
def trasverse_levelorder(self): levels = [[]] q = Queue() q.enqueue({"node": self.root, "level": 0}) while not q.queue_empty(): x = q.dequeue() # Save node to appropriate level. if x["level"] == len(levels): # Create new level. levels.append([x["node"].key]) else: # Save to existing level. levels[x["level"]].append(x["node"].key) # Proceed with the queue. if x["node"].left is not None: q.enqueue({"node": x["node"].left, "level": x["level"] + 1}) if x["node"].right is not None: q.enqueue({"node": x["node"].right, "level": x["level"] + 1}) return levels
def pre_order_traversal(self) -> Queue: """ This method performs a recursive pre-order traversal of the tree, and returns a my_queue object that contains values of visited nodes, in the order they were visited. """ q = Queue() self.pre_order_traversal_helper(q, self.root) return q
def bfs(land, r, c, rows, cols): q = Queue() land[r][c] = False q.push((r, c)) while not q.is_empty(): x, y = q.pop() for i, j in [(x, y + 1), (x, y - 1), (x + 1, y), (x - 1, y)]: if i in range(rows) and j in range(cols) and land[i][j]: land[i][j] = False q.push((i, j)) return
def __str__(self): """ ------------------------------------------------------- Description: Returns a string representation of bst Uses Breadth First Search (BFS) Assert: none Use: str(bst) or print(bst) ------------------------------------------------------- Parameters: None Returns: output: string representation of bst (str) ------------------------------------------------------- """ q = Queue(self.MAX_SIZE) output = '' q.insert(self._root) level = 1 while not q.is_empty(): node = q.remove() if node is None: continue node_level = self.level(node._data) if node_level == level: output += '{} '.format(str(node._data)) elif node_level > level: output = '{}\n'.format(output[:-1]) output += '{} '.format(str(node._data)) level += 1 if node._left is not None: q.insert(node._left) if node._right is not None: q.insert(node._right) return output[:-1]
def shred_queue(queue, size): """ ------------------------------------------------------- Description: shreds a queue into several equal sized queues of given size. Items of the queue is distributed sequentially into the minoir queues. If given size is invalid, print error message and return empty list At the end of the shredding process the input queue should be restored. Use: queue_list = shred_queue(queue,size) ------------------------------------------------------- Parameters: queue - a queue containing arbitrary items (Queue) size - size of each mini queue (int) Returns: queues - a list containing mini queues (list) ------------------------------------------------------- """ queues = [] q = deepcopy(queue) if isinstance(size, int) and size > 0 and size < len(q) + 1: i = 0 if len(queue) % size == 0: num_queues = len(queue) // size else: num_queues = len(queue) // size + 1 while i < num_queues: new_queue = Queue(size) for _ in range(size): if q.is_empty(): break else: new_queue.insert(q.remove()) queues.append(new_queue) i += 1 else: print("Error(shred_queue): invalid shred size") return queues
def by_level_traversal(self) -> Queue: """ This method performs by-level traversal of the tree, and returns a my_queue object that contains values of visited nodes, in the order they were visited. """ height = self.height() queue = Queue() for i in range(height + 1): self.by_level_traversal_helper(queue, self.root, i) return queue
def _reflect_vertical_aux(self, node): queue = Queue() tree = BST() if node is None: return tree if node is not None: queue.insert(node) while not queue.is_empty(): temp = node._left node._left = node._right node._right = temp node = queue.remove() tree.insert(node._data) if node._left is not None: queue.insert(node._left) if node._right is not None: queue.insert(node._right) return tree
def print_animation(self, names: list, num: int): circle_q = Queue() for name in names: circle_q.put(name) while True: # Stop the process when only one name remains if circle_q.size() == 1: break # When passing a potato, the simulation will simply dequeue and then immediately # enqueue the child, putting her at the end of the line for i in range(num): front_child = circle_q.get() circle_q.put(front_child) print("Time:", i) print(self.circle_q_to_str(names, front_child)) time.sleep(1) # After passing potatoes `num` times, the child at the front will be removed permanently name = circle_q.get() names.remove(name) print('\n') print("The last man:", circle_q.get())
def main(): count = 0 maxFrames = 72 color_buffer = Queue() # Buffer for color frames greyscale_buffer = Queue() # Buffer for grey frames video_capture = cv2.VideoCapture("clip.mp4") # Create VideoCapture obj threads = [ # configure threads to run specific functions Thread( target=extract_frames, args=[video_capture, maxFrames, color_buffer], ), # Func spec Threads Thread(target=convert_frames, args=[color_buffer, greyscale_buffer]), Thread(target=render, args=[greyscale_buffer]), ] for t in threads: # For each thread t.start() # start thread for t in threads: # For each thread t.join() # join the threads (wait on all threads)
def test_get(self): q = Queue() q.put(1) i = q.get() self.assertEqual(1, i) with self.assertRaises(IndexError): i = q.get()
def __str__(self): """ ------------------------------------------------------- Description: Returns a string representation of bst Uses Breadth First Search (BFS) Assert: none Use: str(bst) or print(bst) ------------------------------------------------------- Parameters: None Returns: output: string representation of bst (str) ------------------------------------------------------- """ # You can all the way down print the depth (DFS depth first search) --> Stacks # Horizontal search, reads horizontally to prints (BFS breath first search) --> Queues q = Queue(self.MAX_SIZE) output = '' q.insert(self._root) level = 1 # come back to this in WEEK #11 while not q.is_empty(): node = q.remove() if node is None: continue node_level = self.level(node._data) if node_level == level: output += str(node._data) + ' ' elif node_level > level: output = output[:-1] + '\n' output += str(node._data) + ' ' level += 1 if node._left is not None: q.insert(node._left) if node._right is not None: q.insert(node._right) return output[:-1]
def bfs(start: Vertex): """Breadth first search which does not effect the edges of the graph""" v_queue = Queue() v_queue.put(start) while not v_queue.empty(): curr_v = v_queue.get() for nbr in curr_v.get_out_neighbors(): if not nbr.color: nbr.color = 'g' nbr.add_in_neighbor(curr_v) v_queue.put(nbr) else: pass # TODO: delete out_neighbor of curr_v # TODO: delete in_neighbor of nbr curr_v.color = 'b'
class AnimalShelter: def __init__(self): self.dogs = Queue() self.cats = Queue() self.counter = 0 def enqueue(self, *, name, species): if species in Animal.VALID_SPECIES: self.counter += 1 getattr(self, f"{species}s").push( Animal(name=name, species=species, counter=self.counter)) else: raise AttributeError("INVALID TYPE") def dequeue_cat(self): if self.cats.is_empty(): raise IndexError("EMPTY CAT QUEUE") else: return self.cats.pop().name def dequeue_dog(self): if self.dogs.is_empty(): raise IndexError("EMPTY DOG QUEUE") else: return self.dogs.pop().name def dequeue_any(self): if self.dogs.is_empty() and self.cats.is_empty(): raise IndexError("EMPTY QUEUE") elif self.dogs.is_empty(): return self.dequeue_cat() elif self.cats.is_empty(): return self.dequeue_dog() else: return self.dequeue_cat() if self.dogs.peek( ).counter > self.cats.peek().counter else self.dequeue_dog()
def breadth_first_search_adjlist(graph, source, destination): if not source in graph.vertices: print('Source does not exist in graph') return if not destination in graph.vertices: print('destination does not exist in graph') return #Set inital parameters for source vert, enqueue source graph.vertex_object[source].color = 'grey' graph.vertex_object[source].distance = 0 graph.vertex_object[source].prev_search = None bfs_queue = Queue() bfs_queue.enqueue(source) #BFS while loop. Search closest nodes and set distances from source/build tree while not bfs_queue.is_empty(): current_vert = graph.vertex_object[bfs_queue.dequeue()] print(current_vert.name) for vertex in graph.vertices[current_vert.name]: if graph.vertex_object[vertex].color == 'white': graph.vertex_object[vertex].color = 'grey' graph.vertex_object[ vertex].distance = current_vert.distance + 1 graph.vertex_object[vertex].prev_search = current_vert.name bfs_queue.enqueue(vertex) print('Vertex:' + vertex) vertex_iterator = graph.vertex_object[destination] bfs_stack = [] while vertex_iterator != graph.vertex_object[source]: if not vertex_iterator.prev_search: print('No path between source and destination') return bfs_stack.append(vertex_iterator.name) vertex_iterator = graph.vertex_object[vertex_iterator.prev_search] bfs_stack.append(source) print([x for x in reversed(bfs_stack)])
def bfs(gui, one_step=False): starting_pos = gui.grid.head.get_node() fringe = Queue() # Fringe holds a list of tuples: (node position, move to get prev to current, cost) fringe.enqueue([(starting_pos, None, 0)]) path = [] visited = [starting_pos] while not fringe.is_empty(): # Get the next one to be popped off the stack to search it's neighbor nodes (successors) path = fringe.dequeue() if gui.grid.grid[path[-1][0][0]][path[-1][0][1]] == 3: break for neighbor in get_neighbors(gui, path[-1][0][0], path[-1][0][1]): if neighbor[0] not in visited: updated_path = copy.copy(path) updated_path.append(neighbor) fringe.enqueue(updated_path) if not gui.grid.grid[neighbor[0][0]][neighbor[0][1]] == 3: visited.append(neighbor[0]) if not fringe.is_empty(): move_set = [] while path: temp = path.pop(0) if temp[1] is not None: move_set.append(temp[1]) if not one_step: return move_set else: return [move_set[0]] else: no_bfs_move = go_furthest(gui) if no_bfs_move: return no_bfs_move else: no_moves_at_all = go_down() return no_moves_at_all
def find_nearest_shop(self): visited = [] queue = Queue() queue.push(self.__start_index) while queue.size() != 0: current = queue.pop() if current is not None: if self.__shop_lists[current] != 0: return current for e in range(len(self.__map[current])): if self.__map[current][e] != 0 and e not in visited: queue.push(e) visited.append(current) return None
def paint_fill_bfs(screen, x, y, new): old = screen[x][y] if old == new: return q = Queue() q.push((x, y)) screen[x][y] = new while q.length > 0: r, c = q.pop() surrounding = [(r - 1, c), (r, c + 1), (r + 1, c), (r, c - 1)] for t, s in surrounding: if (t in range(len(screen)) and s in range(len(screen[0])) and screen[t][s] == old): screen[t][s] = new q.push((t, s)) return
def simulate(num_seconds, pages_per_minute): printer = Printer(pages_per_minute) print_queue = Queue() waiting_times = [] for curr_sec in range(num_seconds): if is_create_new_print_task(): task = RandomTask(curr_sec) print_queue.put(task) if (not printer.is_busy()) and (not print_queue.empty()): next_task = print_queue.get() waiting_times.append(next_task.get_wait_time(curr_sec)) printer.start_next(next_task) printer.tick() avg_wait_time = sum(waiting_times) / len(waiting_times) return avg_wait_time, print_queue.size()
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.empty()): nexttask = printQueue.dequeue() waitingtimes.append(nexttask.waitTime(currentSecond)) labprinter.startNext(nexttask) labprinter.tick() averageWait = sum(waitingtimes) / len(waitingtimes) print("Average Wait %6.2f secs %3d tasks remaining." % (averageWait, printQueue.size()))
class Stack: def __init__(self): self.__stack = Queue() # Adds value to the end of the Stack. # Complexity: O(1) # push(value) def push(self, value): self.__stack.push(value) # Returns value from the end of the Stack and removes it. # Complexity: O(1) # pop() def pop(self, pop_type=None): new_stack = Queue() while self.__stack.size() > 0: current_value = self.__stack.pop() if self.__stack.size() == 0: if pop_type is not None: new_stack.push(current_value) self.__stack = new_stack return current_value new_stack.push(current_value) # Returns value from the end of the Stack without removing it. # Complexity: O(1) def peek(self): return self.pop(1) # Returns the number of elements in the Queue. # Complexity: O(1) def size(self): return self.__stack.size() def getStack(self): return self.__stack.getQueue()
def reverse_stack(stack): """ ------------------------------------------------------- Description: Reverse a stack using a queue Use: reverse_stack(stack) ------------------------------------------------------- Parameters: stack - a stack of items (Stack) Returns: No returns ------------------------------------------------------- """ queue = Queue() while not stack.is_empty(): item = deepcopy(stack.pop()) queue.insert(item) while not queue.is_empty(): stack.push(queue.remove()) return
print("container of size: " + str(lis.get_size()) + ":") print(lis) print(lis.pop_front()) print(lis.pop_front()) print(lis.pop_front()) print(lis.pop_front()) print("container of size: " + str(lis.get_size()) + ":") print(lis) print(lis.pop_front()) print(lis.pop_front()) print("container of size: " + str(lis.get_size()) + ":") print(lis) print("\nTESTING QUEUE WITH ARRAYS\n") queue = Queue("array") queue.add(2) queue.add(4) queue.add(7) print("the data structure is of size: " + str(queue.get_size())) print(queue.remove()) print(queue.remove()) print(queue.remove()) print(queue.remove()) print("the data structure is of size: " + str(queue.get_size())) print("\nTESTING STACK WITH ARRAYS\n") stack = Stack("array") stack.push(2) stack.push(4)
def __init__(self): self.__stack = Queue()
print(stack.pop()) '''------------Second Part--------------''' # user enters str values into stack line = input("Enter a string,'end' to stop: ") while (line != 'end'): stack.push(line) line = input("Enter a string,'end' to stop:") # user typed str values are removed from stack and printed while not(stack.is_empty()): print(stack.pop()) '''-------------Third Part----------------''' # same user interaction as before, except use a Queue instead of Stack queue = Queue() line = int(input("Enter a string,'end' to stop: ")) while (line != 'end'): queue.enqueue(line) #convert line to an int unless it is 'end' line = (input("Enter a string,'end' to stop:")) if line != 'end': line = int(line) product = 1 while not(queue.is_empty()): product *= queue.dequeue() print(product)