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
