def levelOrder(self, root: TreeNode) -> List[List[int]]: if not root: return [] queue = SimpleQueue() queue.put(root) res = [] level_count = 1 curr_level = [] while queue.qsize(): curr = queue.get() level_count -= 1 curr_level.append(curr.val) if curr.left: queue.put(curr.left) if curr.right: queue.put(curr.right) if not level_count: res.append(curr_level) level_count = queue.qsize() curr_level = [] return res
class BoundedBlockingQueue(object): def __init__(self, capacity: int): self.enque_lock = Lock() self.deque_lock = Lock() self.cap = capacity self.q = SimpleQueue() self.deque_lock.acquire() def enqueue(self, element: int) -> None: self.enque_lock.acquire() self.q.put(element) if self.q.qsize() < self.cap: self.enque_lock.release() if self.deque_lock.locked(): self.deque_lock.release() def dequeue(self) -> int: self.deque_lock.acquire() val = None if self.q.qsize() > 0: val = self.q.get() if self.q.qsize(): self.deque_lock.release() if val and self.enque_lock.locked(): self.enque_lock.release() return val def size(self) -> int: return self.q.qsize()
class MessageBuffer: def __init__(self, batch_size): self._buffer = SimpleQueue() self.set_batch_size(batch_size) def put(self, mesg): self._buffer.put(mesg) return self.batch_size - self._buffer.qsize() def get(self): if not self._buffer.empty(): return self._buffer.get() return None def is_batch_ready(self): return self.batch_size <= self._buffer.qsize() def empty(self): return self._buffer.empty() def set_batch_size(self, batch_size): if batch_size < 1 or not isinstance(batch_size, (int, float)): batch_size = 1 self.batch_size = int(batch_size) def get_batch_size(self): return self.batch_size
def main(): respGen = RespGen.RespGen() q = SimpleQueue() cred = DouUtil.getCred() pwd = cred['pwd'] userName = cred['userName'] loginReqUrl = '' # s = requests.Session() reqWrapper = requestsWrapper.ReqWrapper() s = reqWrapper._session s.headers.update({ 'Host': 'www.douban.com', 'Connection': 'keep-alive', 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:60.0) Gecko/20100101 Firefox/60.0', 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', 'Accept-Language': 'en-US,en;q=0.5', }) s.cookies.update(DouUtil.loadCookies()) slctr = NewPostSelector.NewPostSelector(q, reqWrapper) timeToSleep = 5 combo = 0 while True: q = slctr.select() if q.qsize() == 0: log.debug("sleep fro emty queue: ", timeToSleep) time.sleep(timeToSleep) else: timeToSleep = 5 log.info("****selection, q size: ", q.qsize(), "timeToSleep: " + str(timeToSleep) + "****") try: file = open('resources/record.txt', 'a', encoding='utf-8') recorder = open('resources/histo.txt', "a", encoding='utf-8') while q.qsize() > 0: tup = q.get(timeout=3) question, postUrl, dajie = tup[0], tup[1], tup[2] resp = respGen.getResp(question, dajie) postCmnt(reqWrapper, postUrl, question, resp) sleepCmnt = random.randint(20, 30) log.debug("sleep cmnt: ", sleepCmnt) recorder.write(postUrl.split('/')[5] + '\n') record = question + ': ' + resp['ans'] + '\n' file.write(record) except Empty: log.info("Emptied q, one round finished") finally: file.close() recorder.close() DouUtil.flushCookies(s)
def alienOrder(self, words: List[str]) -> str: # perform a topological sort on the input letters graph = Graph({}, {}) print(words) for word in words: for i, c in enumerate(word): if c not in graph.nodes: node = Node(c, set(), set()) graph.nodes[c] = node else: node = graph.nodes[c] if i != 0 and word[i - 1] != word[i]: parent_char = word[i - 1] parent_node = graph.nodes[parent_char] edge_tuple = (parent_char, word[i]) if edge_tuple not in graph.edges: edge = Edge(parent_node, node) graph.edges[edge_tuple] = edge else: edge = graph.edges[edge_tuple] if edge not in parent_node.outbound_edges: parent_node.outbound_edges.add(edge) if edge not in node.inbound_edges: node.inbound_edges.add(edge) sources = SimpleQueue() for node in graph.nodes.values(): if not len(node.inbound_edges): sources.put(node) sorting = [] while sources.qsize(): next_sources = SimpleQueue() while sources.qsize(): curr = sources.get() child_nodes = [edge.child for edge in curr.outbound_edges] for child in child_nodes: edge_tuple = (curr.value, child.value) # keep graph & nodes in sync edge = graph.edges[edge_tuple] del graph.edges[edge_tuple] child.inbound_edges.remove(edge) if not len(child.inbound_edges): next_sources.put(child) del graph.nodes[curr.value] sorting.append(curr.value) sources = next_sources return "".join(sorting) \ if not len(graph.nodes) \ else ""
def calc_stage1_corners_ud(): # stage 1 can be completed in 12 moves or fewer stage1_corners_ud = bytearray([12] * cube_model.StateSize.CO_ORI * cube_model.StateSize.UD_COMB) stage1_corners_ud[0] = 0 # first entry is solved so takes 0 move to get to # [co_ori, eg_ori, ud_edges, last_move] state = array('I', [0, 0, 0, 255]) # a new cube queue = SimpleQueue() queue.put(state) n = 0 last_print = 0 start_time = time() # logs while queue.qsize() > 0: cur_state = queue.get() # pop cur_idx = cur_state[0] * cube_model.StateSize.UD_COMB + cur_state[2] move_count = stage1_corners_ud[ cur_idx] # get the move count up to this state last_move = cur_state[3] for move in cube_model.MoveSpace: cur_face = move // 3 last_face = last_move // 3 if cur_face == last_face: continue elif cur_face == 3 and last_face == 1: continue elif cur_face == 4 and last_face == 2: continue elif cur_face == 5 and last_face == 0: continue next_state = copy(cur_state) # get a copy of cur state stage1_move(next_state, move) # compute next state next_idx = next_state[ 0] * cube_model.StateSize.UD_COMB + next_state[2] next_count = stage1_corners_ud[next_idx] # get moves count if next_count > move_count + 1: stage1_corners_ud[next_idx] = move_count + 1 next_state[3] = move queue.put(next_state) n += 1 if (n - last_print > 100): last_print = n print(n, str(queue.qsize() // 1000) + 'k', move_count, round((time() - start_time) / 60, 2)) print(n) np.save("table/stage1_corners", np.array(stage1_corners_ud, dtype=np.uint8))
def serialize(self, root): """Encodes a tree to a single string. :type root: TreeNode :rtype: str """ level = SimpleQueue() level.put(root) level_count = 1 if root else 0 res = [] while level_count: next_level_count = 0 next_level = SimpleQueue() while level.qsize(): curr = level.get() if curr: val = str(curr.val) for node in [curr.left, curr.right]: next_level.put(node) if node: next_level_count += 1 else: val = '' next_level.put(None) next_level.put(None) res.append(val) level_count = next_level_count level = next_level return ','.join(res)
def slidingPuzzle(self, board: List[List[int]]) -> int: endstate = tuple([tuple([1, 2, 3]), tuple([4, 5, 0])]) q = SimpleQueue() q.put(tuple(map(tuple, board))) d = {} d[tuple(map(tuple, board))] = 0 def genstate(s): s = list(map(list, s)) for i in range(2): for j in range(3): if s[i][j] != 0: continue for ni, nj in zip([i - 1, i, i + 1, i], [j, j + 1, j, j - 1]): if ni < 0 or ni > 1 or nj < 0 or nj > 2: continue news = list(map(list, s)) news[ni][nj], news[i][j] = news[i][j], news[ni][nj] yield tuple(map(tuple, news)) while q.qsize(): state = q.get() if state == endstate: return d[state] for nxtstate in genstate(state): if nxtstate == endstate: return d[state] + 1 if nxtstate in d: continue d[nxtstate] = d[state] + 1 q.put(nxtstate) return -1
def escape_maze(): maze = [] maze.append(['#', '#', 'O', '#', '#', '#', '#']) maze.append(['#', ' ', ' ', ' ', '#', ' ', '#']) maze.append(['#', ' ', '#', ' ', '#', ' ', '#']) maze.append(['#', ' ', '#', ' ', ' ', ' ', '#']) maze.append(['#', ' ', '#', '#', '#', ' ', '#']) maze.append(['#', ' ', ' ', ' ', '#', ' ', '#']) maze.append(['#', '#', '#', '#', '#', 'X', '#']) directions = [(1, 0), (-1, 0), (0, 1), (0, -1)] visited = [row[:] for row in maze] p_end = (6, 5) p0 = (0, 2) q = SimpleQueue() q.put(p0) time = 0 while not q.empty(): for _ in range(q.qsize()): x = q.get() visited[x[0]][x[1]] = str(time) if x[0] == p_end[0] and x[1] == p_end[1]: return visited for d in directions: p1 = (x[0] + d[0], x[1] + d[1]) if visited[p1[0]][p1[1]] in ' X': q.put(p1) time += 1 return None
def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int: q = SimpleQueue() wl = set([beginWord] + wordList) g = defaultdict(list) l = len(beginWord) for w in wl: for i in range(l): for c in 'abcdefghijklmnopqrstuvwxyz': nw = w[:i] + c + w[i + 1:] if nw == w or nw not in wl: continue g[w].append(nw) g[nw].append(w) q.put((beginWord, 1)) seen = set([beginWord]) while q.qsize(): w, dist = q.get() for nw in g[w]: if nw == endWord: return dist + 1 # print(w, '->', nw) if nw in seen: continue seen.add(nw) q.put((nw, dist + 1)) return 0
def minJumps(self, arr: List[int]) -> int: same_val, N = defaultdict(list), len(arr) flag = [float('inf')] * N for i, v in enumerate(arr): same_val[v].append(i) q = SimpleQueue() q.put(0) flag[0] = 0 while q.qsize(): if flag[N - 1] < float('inf'): return flag[N - 1] top = q.get() # print(top) if top - 1 > 0 and flag[top] + 1 < flag[top - 1]: flag[top - 1] = flag[top] + 1 q.put(top - 1) if top + 1 < N and flag[top] + 1 < flag[top + 1]: flag[top + 1] = flag[top] + 1 q.put(top + 1) for nxt in same_val[arr[top]]: if flag[top] + 1 < flag[nxt]: flag[nxt] = flag[top] + 1 q.put(nxt) del same_val[arr[top]] return flag[N - 1]
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool: g = defaultdict(list) indegree = [0] * numCourses for to, frm in prerequisites: g[frm].append(to) indegree[to] += 1 q = SimpleQueue() for i, v in enumerate(indegree): if not v: q.put(i) removed = 0 while q.qsize(): top = q.get() removed += 1 for n in g[top]: indegree[n] -= 1 if indegree[n] == 0: q.put(n) return removed == numCourses
class Game: def __init__(self): """An instance of the game engine. Handles events and maintains the current state of the game.""" self.run = True self.action_queue = SimpleQueue() self.game_loop_thread = Thread(target=self._game_loop) self.game_loop_thread.start() self.objects = {} def pass_action(self, action: Action): self.action_queue.put(action) def destroy_object(self, obj): pass def _game_loop(self): clock = Clock(15) while self.run: for i in range(self.action_queue.qsize()): a = self.action_queue.get() if a.target == -1: # Denotes a game-wide action. pass else: # Action relates to a specific object in the game. try: obj: GameObject = self.objects[a.target] obj.handle_action(a) except KeyError: print("Action for unknown object!") except InvalidActionError: print("Invalid action.") clock.tick()
def breadth_first_spelunking(player, graph): breadcrumbs = SimpleQueue() visited_rooms = set([]) breadcrumbs.put_nowait([player.current_room.id]) # retrace path as long as there are breadcrumbs in the queue while not breadcrumbs.qsize() is 0: path = breadcrumbs.get_nowait() last_room = path[-1] # Check if we hit an unexplored room if last_room not in visited_rooms: # Log it visited_rooms.add(last_room) # Check exits for room_exit in graph[last_room]: # Return path if we find an unexplored exit if graph[last_room][room_exit] is "?": return path # Otherwise, keep on truckin' else: breadcrumb_path = list(path) breadcrumb_path.append(graph[last_room][room_exit]) breadcrumbs.put_nowait(breadcrumb_path) # when we run out of breadcrumbs in our queue, return an empty list # as we exit the loop since we're back at an unexplored path return list()
def processing(): threads = [] tasks_queue = SimpleQueue() results_queue = SimpleQueue() for _ in range(16): thread = threading.Thread(target=thread_main, args=( tasks_queue, results_queue, )) threads.append(thread) for _ in range(tasks_count()): task = retrieve_task() tasks_queue.put(task) for thread in threads: thread.start() for thread in threads: thread.join() for _ in range(results_queue.qsize()): result = results_queue.get(block=False) populate_result(result)
def alienOrder(self, words: List[str]) -> str: try: nodes = self.getGraph(words) except ValueError: return '' sources = [node for node in nodes if node and not node.inbound] q = SimpleQueue() for s in sources: q.put(s) res = [] seen = set() while q.qsize(): curr = q.get() if curr.val in seen: continue seen.add(curr.val) res.append(curr.val) for n in curr.outbound: node = nodes[self._to_idx(n)] node.inbound.remove(curr.val) if not node.inbound: q.put(node) return ''.join(res) if len(seen) == len(list(filter(None, nodes))) else ''
def openLock(self, deadends: List[str], target: str) -> int: deadends, seen = set(deadends), set() q = SimpleQueue() if '0000' not in deadends: q.put(('0000', 0)) seen.add('0000') def get_next(s): for i in range(4): val = int(s[i]) for x in [val - 1, val + 1]: if x >= 10: x -= 10 elif x < 0: x += 10 yield s[:i] + str(x) + s[i + 1:] while q.qsize(): now, cost = q.get() if now == target: return cost for nxt in get_next(now): if nxt in seen or nxt in deadends: continue q.put((nxt, cost + 1)) seen.add(nxt) return -1
def serialize(self, root): """Encodes a tree to a single string. :type root: TreeNode :rtype: str """ if not root: return "" q = SimpleQueue() ans = str(root.val) + ',' q.put(root) while q.qsize(): top = q.get() l = top.left r = top.right if l: ans += str(l.val) + ',' q.put(l) else: ans += '#,' if r: ans += str(r.val) + ',' q.put(r) else: ans += '#,' return ans[:-1]
def bft_print(self, node): to_print = SimpleQueue() to_print.put(node) while to_print.qsize() != 0: node = to_print.get() print(node.value) if node.left is not None: to_print.put(node.left) if node.right is not None: to_print.put(node.right)
def level_order_iterator(cls, root): queue = SimpleQueue() queue.put(root) while not queue.empty(): level_elements = [] for _ in range(queue.qsize()): curr = queue.get() level_elements.append(curr.val) for child in curr.children: queue.put(child) yield level_elements
def canMeasureWater(self, x: int, y: int, z: int) -> bool: if z > x + y: return False q = SimpleQueue() q.put((0, 0)) seen = set((0, 0)) while q.qsize(): a, b = q.get() if a == z or b == z or a + b == z: return True # Fill a state = (x, b) if state not in seen: seen.add(state) q.put(state) # Fill b state = (a, y) if state not in seen: seen.add(state) q.put(state) # Pour a -> b rem_y = y - b poure_amount = min(rem_y, a) state = (a - poure_amount, b + poure_amount) if state not in seen: seen.add(state) q.put(state) # Pour a <- b rem_x = x - a poure_amount = min(rem_x, b) state = (a + poure_amount, b - poure_amount) if state not in seen: seen.add(state) q.put(state) # Empty a state = (0, b) if state not in seen: seen.add(state) q.put(state) # Empty b state = (a, 0) if state not in seen: seen.add(state) q.put(state) return False
def bfs(node: Node, graph: Graph): queue = SimpleQueue() marked: dict = {node.id: True} queue.put(node) while queue.qsize() > 0: item = queue.get() if graph.adj[item.id] is not None: print("visited vertex: " + item.name) for v in graph.adj[item.id]: if not marked.get(v.id, False): marked[v.id] = True queue.put(v)
def mergeKLists(self, lists: List[ListNode]) -> ListNode: if len(lists) == 0: return None q = SimpleQueue() for l in lists: q.put(l) while(q.qsize() > 1): q.put(self.merge(q.get(), q.get())) return q.get()
def solution2(self, root: TreeNode) -> int: q = SimpleQueue() q.put(root) ans = 0 while not q.empty(): for _ in range(q.qsize()): node = q.get() if node.left: q.put(node.left) if node.right: q.put(node.right) ans += 1 return ans
def find_shortest_path(self, vtx_A, vtx_B): """ Use bfs to find the shortest path from a start vertex to an end vertex. Args: vtx_A (any): The start vertex. vtx_B (any): The end vertex. Returns: result ([any]): List of vertex ids in order of traversal. Raises: Exception: If vtx_A or vtx_B not in graph. """ # ensure that vtxA and vtxB are in graph if vtx_A not in self.vertices or vtx_B not in self.vertices: raise Exception( f"One or both of the supplied vertices {vtx_A}, {vtx_B} \ is not in this graph.") # create our needed structures result = [] visited = set() queue = SimpleQueue() # initialize queue with start vertex queue.put(self.vertices[vtx_A]) # while there are vertices in the queue while queue.qsize() > 0: # dequeue a vertex curVtx = queue.get() # if the vertex has not been visited if curVtx not in visited: # add it to visited set and result list visited.add(curVtx) result.append(curVtx.id) # iterate through its neighbors for neighbor in curVtx.get_neighbors(): # if the neighbor is the vertex we are looking for, we are # done append the neighbor to the result and return if neighbor.id == vtx_B: result.append(neighbor.id) return result # otherwise, put the neighbor in the queue queue.put(neighbor) # return result list of vertex ids return result
def averageOfLevels(self, root: TreeNode): if not root: return [0] q = SimpleQueue() q.put(root) ans = [] while not q.empty(): total, size = 0, q.qsize() for _ in range(size): node = q.get() total += node.val if node.left: q.put(node.left) if node.right: q.put(node.right) ans.append(total/size) return ans
def bfs(s): planned = SimpleQueue() planned.put(s) colors[s] = 'gray' path = str(s) while planned.qsize() != 0: u = planned.get() for v in graph[u]: if colors[v] == 'white': colors[v] = 'gray' planned.put(v) path += ' ' + str(v) colors[u] = 'black' return path
def bfs(s): global max_distance planned = SimpleQueue() planned.put(s) colors[s] = 'gray' distances[s] = 0 while planned.qsize() != 0: u = planned.get() for v in graph[u]: if colors[v] == 'white': distances[v] = distances[u] + 1 if max_distance <= distances[u] + 1: max_distance = distances[u] + 1 colors[v] = 'gray' planned.put(v) colors[u] = 'black'
def maxDepth2(self, root: TreeNode) -> int: if not root: return 0 q = SimpleQueue() q.put(root) dept = 0 while not q.empty(): levelSize = q.qsize() dept += 1 for _ in range(levelSize): node = q.get() if node.left: q.put(node.left) if node.right: q.put(node.right) return dept
def hasPath(self, maze: List[List[int]], start: List[int], destination: List[int]) -> bool: if not maze or not maze[0]: return False R, C = len(maze), len(maze[0]) s = set(tuple(start)) q = SimpleQueue() q.put(start) def add_queue(r, c): tup = (r, c) if tup in s: return q.put(tup) s.add(tup) while q.qsize(): r, c = q.get() if tuple(destination) == (r, c): return True # Go left for i in range(c - 1, -2, -1): if i == -1 or maze[r][i] == 1: add_queue(r, 0 if i == -1 else i + 1) break # Go right for i in range(c + 1, C + 1): if i == C or maze[r][i] == 1: add_queue(r, C - 1 if i == C else i - 1) break # Go up for i in range(r - 1, -2, -1): if i == -1 or maze[i][c] == 1: add_queue(0 if i == -1 else i + 1, c) break # Go down for i in range(r + 1, R + 1): if i == R or maze[i][c] == 1: add_queue(R - 1 if i == R else i - 1, c) break return False