def checkValidString(self, s: str) -> bool:
open_parant_count = 0
star_queue = SimpleQueue()
for index, c in enumerate(s):
if c == '*':
star_queue.put(index)
elif c == '(':
open_parant_count += 1
elif open_parant_count > 0:
open_parant_count -= 1
elif not star_queue.empty():
pos = star_queue.get()
s = s[:pos] + '(' + s[pos + 1:]
else:
return False
open_parant_count = 0
star_queue = SimpleQueue()
for index, c in enumerate(s[::-1]):
if c == '*':
star_queue.put(index)
elif c == ')':
open_parant_count += 1
elif open_parant_count > 0:
open_parant_count -= 1
elif not star_queue.empty():
pos = star_queue.get()
s = s[:pos] + '(' + s[pos + 1:]
else:
return False
return True
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 get_cost(work: SimpleQueue, recipe_book: Dict[str, Recipe],
extra: Dict[str, int]) -> int:
ore_used = 0
while not work.empty():
to_make: Component = work.get()
# Ore is infinite, we can just use it
if to_make.substance == "ORE":
ore_used += to_make.amount
continue
# Use up anything we already have
usable = min(extra[to_make.substance], to_make.amount)
to_make.amount -= usable
extra[to_make.substance] -= usable
# Dont need to craft it if you dont need it
if to_make.amount == 0:
continue
recipe = recipe_book[to_make.substance]
scaling_factor = math.ceil(to_make.amount / recipe.result.amount)
for ingredient in recipe.ingredients:
work.put(scaling_factor * ingredient)
leftover = (scaling_factor * recipe.result.amount) - to_make.amount
extra[to_make.substance] += leftover
return ore_used
def bfs(self, node_key: int, upside_down: bool):
"""
gets src and runs bfs algorithm on the graph from src
if upside down is true that run the bfs on graph transpose
:param node_key:
:param upside_down:
:return:
"""
# initialize all the tags to -1
for node in self.my_graph.get_all_v().values():
if node.get_color != "Red" or node.connected_component is None: #checks if we are in red mode then only nodes that dont have SCC
# participants in the bfs
node.set_tag(-1)
queue = SimpleQueue()
src = self.my_graph.get_all_v().get(node_key)
src.set_tag(0)
queue.put(src)
while not queue.empty():
node_temp = queue.get()
# graph as is
if upside_down is False:
neighbors = self.my_graph.all_out_edges_of_node(node_temp.key)
# graph transpose
else:
neighbors = self.my_graph.all_in_edges_of_node(node_temp.key)
for key in neighbors:
node_neighbor = self.my_graph.get_all_v().get(key)
if node_neighbor.get_tag(
) == -1: # the first time this node is reached
node_neighbor.set_tag(0)
queue.put(node_neighbor)
def algorithm(start, end, edges, win):
start.visited = True
queue = SimpleQueue()
queue.put(start)
while not queue.empty():
node = queue.get()
if node != end:
for edge in edges:
if node == edge[0]:
if not edge[1].visited:
queue.put(edge[1])
edge[1].parent = node
edge[1].visited = True
elif node == edge[1]:
if not edge[0].visited:
queue.put(edge[0])
edge[0].parent = node
edge[0].visited = True
node.make_grey()
else:
end.make_grey()
return True
return False
def run_all(folder, s_target):
sql_queue = SimpleQueue()
size = 0
for filename in glob.iglob(f'{folder}/**/*.sql', recursive=True):
sql_queue.put(get_sql(filename))
size += 1
num_tries = 0
max_tries = size * 2
while not sql_queue.empty() and num_tries < max_tries:
try:
sql = sql_queue.get()
s_target.execute(sql)
s_target.commit()
num_tries = 0
except ProgrammingError as e:
message = str(e.orig).strip()
if 'relation' in message and 'does not exist' in message:
s_target.rollback()
print(f'Object does not exist yet: {message}. Re-queueing...')
sql_queue.put(sql)
num_tries += 1
else:
raise
if num_tries >= max_tries:
print(f'Number of attempts exceeded configured threshold of {max_tries}')
sys.exit(1)
def kahn_topo_sort(grph, nodes, source=None, sink=None):
result = []
in_degrees = find_in_degrees(grph, nodes)
no_inpaths = set([node for node, indg in in_degrees.items() if indg == 0])
q = SimpleQueue()
if source is not None:
# Make sure source is at the start of topo sort
q.put(source)
no_inpaths = no_inpaths - set([source])
for node in no_inpaths:
q.put(node)
while not q.empty():
node = q.get()
result.append(node)
for neigh, wt in grph[node]:
if neigh not in in_degrees:
continue
in_degrees[neigh] -= 1
if in_degrees[neigh] == 0:
q.put(neigh)
if sink is not None and result[-1] != sink:
# if sink is not at the end of topo sort, place it there
sink_index = result.index(sink)
result.append(sink)
result = result[:sink_index] + result[sink_index + 1:]
return result
def ac3(self, arcs=None):
"""
Update `self.domains` such that each variable is arc consistent.
If `arcs` is None, begin with initial list of all arcs in the problem.
Otherwise, use `arcs` as the initial list of arcs to make consistent.
Return True if arc consistency is enforced and no domains are empty;
return False if one or more domains end up empty.
"""
# Create arcs if None
if arcs is None:
arcs = SimpleQueue()
for x in combinations(self.crossword.variables, 2):
arcs.put(x)
while not arcs.empty():
x, y = arcs.get()
if self.revise(x, y):
if not self.domains[x]:
return False
neighbors = self.crossword.neighbors(x)
neighbors.remove(y)
for x_neighbor in neighbors:
arcs.put((x_neighbor, x))
return True
def distance(w1: str, w2: str, words: set) -> (int, list):
d = dict()
q = SimpleQueue()
current = ""
temp = ""
q.put(w1)
d[w1] = w1
if w1 == w2:
return (0, [w1])
while q.empty() == False:
current = q.get()
for letter in range(len(current)):
temp = current
for i in range(97, 123):
temp = temp[:letter] + chr(i) + temp[letter + 1:]
if temp in words:
if d.get(temp) == None:
d[temp] = current
if temp == w2:
return getPath(w1, w2, d)
q.put(temp)
return ([], -1)
def p39(triplet_sum_stop: int) -> int:
initial_triplet = (3, 4, 5)
q = SimpleQueue()
q.put(initial_triplet)
triplet_sum_counts = [0] * triplet_sum_stop
while not q.empty():
triplet = q.get()
triplet_sum = sum(triplet)
if triplet_sum < triplet_sum_stop:
for triplet_sum_multiple in range(triplet_sum, triplet_sum_stop,
triplet_sum):
triplet_sum_counts[triplet_sum_multiple] += 1
a, b, c = calculate_next_triplets(triplet)
q.put(a)
q.put(b)
q.put(c)
largest_triplet_sum = 0
largest_triplet_sum_count = 0
for triplet_sum in range(12, triplet_sum_stop):
triplet_sum_count = triplet_sum_counts[triplet_sum]
if triplet_sum_count > largest_triplet_sum_count:
largest_triplet_sum_count = triplet_sum_count
largest_triplet_sum = triplet_sum
return largest_triplet_sum
def tree_insert(self, key):
if self._root == None:
self._root = BinaryTree.BinaryNode(key)
return self._root
q = Queue()
q.put(self._root)
while not q.empty():
cur_node = q.get()
if cur_node.left == None:
cur_node.left = BinaryTree.BinaryNode(key, cur_node)
return cur_node.left
elif cur_node.right == None:
cur_node.right = BinaryTree.BinaryNode(key, cur_node)
return cur_node.right
if cur_node.left:
q.put(cur_node.left)
if cur_node.right:
q.put(cur_node.right)
return None
def game_player(game_input: OpCodes, opcodes: OpCodes):
"""
Create the processor to play the game
"""
input_queue = SimpleQueue()
output_queue = SimpleQueue()
processor = Processor(input_queue, output_queue)
map(input_queue.putm game_input)
# let the robot run in a separate thread
thread = threading.Thread(target=processor, args=(opcodes, ), daemon=True)
thread.start()
score = 0
while not output_queue.empty():
# not sure where the robot will break, so
x = output_queue.get()
y = output_queue.get()
tile_id = output_queue.get()
if x == -1 and y == 0:
score = max(tile_id, score)
return (score, ) # must return a tuple
class RDProxyClientProtocol:
def __init__(self, server, client_addr):
self.server = server
self.client_addr = client_addr
self.transport = None
self.q = SimpleQueue()
def connection_made(self, transport):
self.transport = transport
self.dispatch_message()
def queue_message(self, message):
self.q.put(message)
self.dispatch_message()
def dispatch_message(self):
if self.transport != None:
while not self.q.empty():
item = self.q.get()
if random.random() >= DROP_RATE:
self.transport.sendto(item)
def datagram_received(self, data, addr):
if random.random() >= DROP_RATE:
self.server.transport.sendto(data, self.client_addr)
def error_received(self, exc):
print('Error received:', exc)
def connection_lost(self, exc):
pass
def __call__(self, problem):
D = problem.D
# Draw samples
X = problem.d.rvs(self.N)
y = problem.pdf(X)
root = Container(X, y, mins=[problem.low] * D, maxs=[problem.high] * D)
# Construct tree
finished_containers = []
q = SimpleQueue()
q.put(root)
while not q.empty():
c = q.get()
if c.N <= self.P:
finished_containers.append(c)
else:
children = self.split(c)
for child in children:
q.put(child)
# Integrate containers
contributions = [
self.integral(cont, problem.pdf) for cont in finished_containers
]
G = np.sum(contributions)
return G
def list_words_lexicographical(self, n: int) -> Generator[str, None, None]:
self._deterministic_only()
if len(self._final_states) == 0:
return
queue = SimpleQueue()
queue.put((self._initial_state, ""))
if self._initial_state in self._final_states:
yield ""
while not (n <= 0 or queue.empty()):
q1, s = queue.get()
for (c_index, c) in self._alphabet_iter(with_epsilon=False):
q2 = sget(self._state_transition_matrix[q1][c_index])
if q2 in self._stock_states:
continue
new_s = s + c
if q2 in self._final_states:
yield new_s
n -= 1
queue.put((q2, new_s))
def bfs(self, node: List[int]):
def rotate_wheel(node: List[int], depth: int, pos: int, incre: int):
assert incre in [1, -1]
new_node = node.copy()
new_node[pos] = (node[pos] + incre) % 10
new_node_str = ''.join(map(str, new_node))
if new_node_str == self.target:
self.min_depth = min(self.min_depth, depth + 1)
self.visited[new_node_str] = None
elif new_node_str not in self.deadends and \
new_node_str not in self.visited:
q.put([new_node, depth + 1])
self.visited[new_node_str] = None
q = SimpleQueue()
q.put([node, 0])
while not q.empty():
node, depth = q.get()
rotate_wheel(node, depth, 0, 1)
rotate_wheel(node, depth, 0, -1)
rotate_wheel(node, depth, 1, 1)
rotate_wheel(node, depth, 1, -1)
rotate_wheel(node, depth, 2, 1)
rotate_wheel(node, depth, 2, -1)
rotate_wheel(node, depth, 3, 1)
rotate_wheel(node, depth, 3, -1)
if self.min_depth == depth + 1: break
def bfs(self, start, target, visited):
# Create an empty queue.
q = SimpleQueue()
# Put the starting userID in a list in our queue.
q.put([start])
# While the queue is not empty....
while not q.empty():
# Grab the current path.
path = q.get()
# Grab the last vertex in the path.
curr_vertex = path[-1]
# If current vertex is the target, return the path.
if curr_vertex == target:
visited[target] = path
return
# Iterate through all neighbors.
for social_connection in self.friendships[curr_vertex]:
if social_connection != start and social_connection not in path:
# Create new path and add current neighbor.
new_path = list(path)
new_path.append(social_connection)
# Add that new path to the queue.
q.put(new_path)
def shortestPath(self, nid1, nid2):
if nid1 == nid2:
return [nid1]
Q = SimpleQueue()
P = [-1 for _ in range(self.order())]
visited = [False for _ in range(self.order())]
Q.put(nid1)
visited[nid1] = True
while not Q.empty():
nid = Q.get()
for next_nid in self._nodes[nid].outneighbours:
if not visited[next_nid]:
if next_nid == nid2:
path = [next_nid]
while nid > -1:
path.append(nid)
nid = P[nid]
return path
P[next_nid] = nid
Q.put(next_nid)
visited[next_nid] = True
return None
def get_details(start_pos, keys, doors, walkable):
q = SimpleQueue()
seen = set()
details = dict()
q.put({"position": start_pos, "distance": 0, "keys_needed": set()})
# queue = [{"position": (int, int), "distance": int, "keys_needed": {string}}]
while not q.empty():
item = q.get()
q_pos = item["position"]
if q_pos in seen:
continue
seen.add(q_pos)
q_distance = item["distance"]
q_keys = item["keys_needed"]
if q_pos in keys.keys():
details[q_pos] = {"distance": q_distance, "keys_needed": q_keys}
if q_pos in doors.keys():
q_keys.add(doors[q_pos].lower())
for n_pos in get_orthogonal_neighbours(q_pos):
if n_pos in walkable - seen:
q.put(
{"position": n_pos, "distance": q_distance + 1, "keys_needed": q_keys.copy()})
return details
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 backward(self, target_node, deriv_pass, ancestors=None):
"""Perform a backward computation to compute the derivatives for all
parameters that affect the target node
Parameters
----------
target_node : integer
The id of the node under consideration
deriv_pass : np.ndarray (nparams)
A gradient vector
Returns
-------
derivative : np.ndarray(nparams)
A vector containing the derivative of all parameters
"""
if ancestors is None:
ancestors = nx.ancestors(self.graph, target_node)
anc_and_target = ancestors.union(set([target_node]))
# Evaluate the node
self.graph.nodes[target_node]['pass_down'] = deriv_pass
# Gradient with respect to beta
self.graph.nodes[target_node]['derivative'] = \
np.dot(self.graph.nodes[target_node]['pass_down'],
self.graph.nodes[target_node]['pre_grad'])
queue = SimpleQueue()
queue.put(target_node)
for node in ancestors:
self.graph.nodes[node]['children_left'] = set(
self.graph.successors(node)).intersection(anc_and_target)
self.graph.nodes[node]['pass_down'] = 0.0
self.graph.nodes[node]['derivative'] = 0.0
while not queue.empty():
node = queue.get()
pass_down = self.graph.nodes[node]['pass_down']
for parent in self.graph.predecessors(node):
self.graph.nodes[parent]['pass_down'] += \
pass_down * self.graph.edges[parent, node]['eval']
self.graph.edges[parent, node]['derivative'] = \
np.dot(pass_down,self.graph.edges[parent, node]['pre_grad'])
self.graph.nodes[parent]['derivative'] += \
np.dot(pass_down * self.graph.edges[parent, node]['eval'],
self.graph.nodes[parent]['pre_grad'])
self.graph.nodes[parent]['children_left'].remove(node)
if self.graph.nodes[parent]['children_left'] == set():
queue.put(parent)
return self.get_derivative()
def run_all(folder, s_target):
sql_queue = SimpleQueue()
size = 0
# Ordered scripts are formatted like {number}-name.sql
# Scripts without a number prefix will be ran last
for filename in sorted(glob.iglob(f'{folder}/**/*.sql', recursive=True), key=get_file_order):
sql_queue.put(get_sql(filename))
size += 1
if size == 0:
return
num_tries = 0
max_tries = size * 2
while not sql_queue.empty() and num_tries < max_tries:
try:
sql = sql_queue.get()
s_target.execute(sql)
s_target.commit()
num_tries = 0
except ProgrammingError as e:
message = str(e.orig).strip()
if 'relation' in message and 'does not exist' in message:
s_target.rollback()
print(f'Object does not exist yet: {message}. Re-queueing...')
sql_queue.put(sql)
num_tries += 1
else:
raise
if num_tries >= max_tries:
print(
f'Number of attempts exceeded configured threshold of {max_tries}')
sys.exit(1)
def game_player(opcodes: OpCodes):
"""
Create the processor to play the game
"""
painting = defaultdict(lambda: 0)
input_queue = SimpleQueue()
output_queue = SimpleQueue()
processor = Processor(input_queue, output_queue)
# let the robot run in a separate thread
thread = threading.Thread(target=processor, name='Game', args=(opcodes, ))
thread.start()
thread.join()
while not output_queue.empty():
# not sure where the robot will break, so
x = output_queue.get()
y = output_queue.get()
tile_id = output_queue.get()
painting[(x, y)] = tile_id
return painting
class Bluetooth(Thread):
Messages = {
"0,0,0,0,0,0,0,0,0": Action.STOP,
"1,0,0,0,0,0,0,0,0": Action.FORWARD,
"2,0,0,0,0,0,0,0,0": Action.BACKWARD,
"3,0,0,0,0,0,0,0,0": Action.LEFT,
"4,0,0,0,0,0,0,0,0": Action.RIGHT,
"0,1,0,0,0,0,0,0,0": Action.LEFT_ALT,
"0,2,0,0,0,0,0,0,0": Action.RIGHT_ALT,
"0,0,1,0,0,0,0,0,0": Action.BEEP,
"0,0,0,1,0,0,0,0,0": Action.SPEED_UP,
"0,0,0,2,0,0,0,0,0": Action.SPEED_DOWN,
"0,0,0,0,1,0,0,0,0": Action.SERVO_LEFT,
"0,0,0,0,2,0,0,0,0": Action.SERVO_RIGHT,
"0,0,0,0,0,0,1,0,0": Action.LED_OFF,
"0,0,0,0,0,0,2,0,0": Action.LED_RED,
"0,0,0,0,0,0,3,0,0": Action.LED_GREEN,
"0,0,0,0,0,0,4,0,0": Action.LED_BLUE,
"0,0,0,0,0,0,0,0,1": Action.SERVO_MID,
"0,0,0,0,0,0,0,1,0": Action.OUTFIRE,
"0,0,0,0,0,0,8,0,0": Action.LED_OFF
}
def __init__(self):
self.serial = Serial("/dev/ttyAMA0", 9600)
Thread.__init__(self)
self.event_queue = SimpleQueue()
self.daemon = True
self.start()
def run(self):
while True:
command_string = self._get_command_string()
action = Bluetooth.Messages[command_string]
action_key = ActionKey(action)
self.event_queue.put(action_key)
def _get_command_string(self):
#wait for start
input_str = ""
while self.serial.read(1).decode() != "$":
pass
#wait for end
while True:
char = self.serial.read(1).decode()
if char == "#":
break
input_str += char
return input_str
def next_action(self):
action_key = None
while action_key == None:
if not self.event_queue.empty():
next = self.event_queue.get(block=False)
if not next.is_old():
action_key = next
return action_key.action
def _determinize_without_epsilon_transitions(self) -> StateMachine:
# implying that no nontrivial (not into itself) epsilon transition exists
q0 = (self._initial_state, )
new_states = {q0}
new_transitions = []
queue = SimpleQueue()
queue.put(q0)
while not queue.empty():
q1 = queue.get()
for c_index, c in self._alphabet_iter():
q2 = set()
for q1n in q1:
q2.update(self._state_transition_matrix[q1n][c_index])
q2 -= self._stock_states
if len(q2) == 0:
continue
q2 = tuple(sorted(q2))
new_transitions.append((q1, c, q2))
if q2 not in new_states:
queue.put(q2)
new_states.add(q2)
new_states = list(new_states)
state_to_index = dict(zip(new_states, range(len(new_states))))
# Form result - new state machine
alphabet = copy.deepcopy(self._alphabet)
states_count = len(new_states)
initial_state = new_states.index((self._initial_state, ))
final_states = {
i
for i, q1 in enumerate(new_states)
if len(set(q1) & self._final_states) != 0
}
state_transition = {(state_to_index[q1], c, state_to_index[q2])
for (q1, c, q2) in new_transitions}
states_labels = []
for q1 in new_states:
if len(q1) == 1:
label = self._states_labels[q1[0]]
else:
label = "{" + ",".join(self._states_labels[q1n]
for q1n in q1) + "}"
states_labels.append(label)
return StateMachine(initial_state,
final_states,
state_transition,
states_labels=states_labels,
alphabet=alphabet,
states_count=states_count)
def levelOrder(self):
from queue import SimpleQueue
FIFOQueue = SimpleQueue()
FIFOQueue.put(self)
self.levelOrderEntry(FIFOQueue)
while not FIFOQueue.empty():
node = FIFOQueue.get()
print(str(node.value), ' ')
def game_player(scr, *args, opcodes: OpCodes):
"""
Create the processor to play the game
"""
painting = defaultdict(lambda: 0)
input_queue = SimpleQueue()
output_queue = SimpleQueue()
processor = Processor(input_queue, output_queue)
# let the robot run in a separate thread
thread = threading.Thread(target=processor,
name='Game',
args=(opcodes, ),
daemon=True)
thread.start()
curses.curs_set(0)
scr.nodelay(True)
scr.border(0)
max_y = 0
score = None
while thread.is_alive():
ch = scr.getch()
if ch == ord(','):
input_queue.put(-1)
elif ch == ord('.'):
input_queue.put(1)
elif ch == ord(' '):
input_queue.put(0)
elif ch == ord('q'):
return 'exit'
while not output_queue.empty():
# not sure where the robot will break, so
x = output_queue.get()
y = output_queue.get()
tile_id = output_queue.get()
if not (x == -1 and y == 0):
painting[(y + 1, x + 1)] = tile_id
max_y = max(max_y, y + 1)
else:
score = tile_id
for location, tile_id in painting.items():
scr.addstr(*location, SYMBOL_MAP[tile_id], curses.A_NORMAL)
if score is not None:
scr.addstr(max_y + 4, 1, str(score), curses.A_BOLD)
scr.clrtoeol()
return painting
def getDoc(docLookupInformation: LookupInformation,
asyncQueue: queue.SimpleQueue, documents: queue.SimpleQueue):
intermediateQueue = queue.SimpleQueue()
isrunning = CancellationToken()
workers = list()
executor = ThreadPoolExecutor(max_workers=2)
future = executor.submit(getDocuments, isrunning, 0, docLookupInformation,
asyncQueue, intermediateQueue)
workers.append(future)
counts = 0
while counts < 10 and (runningWorkers(workers) or not asyncQueue.empty()):
if asyncQueue.empty():
isrunning.cancel()
try:
if not intermediateQueue.empty():
documents.put(intermediateQueue.get())
counts = counts + 1
else:
time.sleep(1)
except Queue.Empty:
pass
while counts < 10 and not intermediateQueue.empty():
try:
if not intermediateQueue.empty():
doc = intermediateQueue.get()
documents.put(doc)
counts = counts + 1
else:
time.sleep(1)
except:
pass
isrunning.cancel()
for worker in workers:
worker.cancel()
executor.shutdown()
class SimpleQueueStore(Store):
def __init__(self):
self._q = SimpleQueue()
self._len = 0
def __len__(self):
return self._len
def store(self, entity, *args, **kwargs):
self._q.put(entity)
self._len += 1
def pop(self, *args, **kwargs):
if self._q.empty():
return None
return self._q.get()
def empty(self):
return self._q.empty()
def intcode_helper(code, input_val=None):
in_msg = SimpleQueue()
if input_val is not None:
in_msg.put(input_val)
out_msg = SimpleQueue()
intcode(code, in_msg, out_msg)
output = []
while not out_msg.empty():
output.append(out_msg.get())
return output
