def make_move(input_circle: deque, current_cup: int) -> deque:
print(f'Current circle: {input_circle}')
current_cup_index = input_circle.index(current_cup)
pick_three = []
for i in range(3):
pick_index = i + current_cup_index + 1
if pick_index > 8:
pick_index -= 9
pick_three.append(input_circle[pick_index])
for cup in pick_three:
input_circle.remove(cup)
destination_cup = current_cup - 1
if destination_cup < 1:
destination_cup += 9
while destination_cup in pick_three:
destination_cup -= 1
# wrap around
if destination_cup < 1:
destination_cup += 9
destination_cup_index = input_circle.index(destination_cup)
for cup in reversed(pick_three):
input_circle.insert(destination_cup_index + 1, cup)
return input_circle
def move_to_front_c(e, v: collections.deque):
eFound = v.count(e)
counter = eFound
while counter != 0:
counter -= 1
v.remove(e)
v.appendleft(e)
print(v)
def iteration(p: deque, c_pos: int):
c_pos %= len(p)
p.rotate(-c_pos)
sel = []
for _ in range(3):
v = p[1]
sel.append(v)
p.remove(v)
d_value = calc_dest_value(p, sel, p[0])
d_pos = p.index(d_value) + 1
for i in range(3):
p.insert(d_pos + i, sel[i])
p.rotate(c_pos)
def getNextRequest(discipline: str, queue: deque):
if (discipline == "FIFO"):
return queue.popleft()
elif (discipline == "LIFO"):
return queue.pop()
elif (discipline == "RAND"):
num = np.random.randint(0, queue.count())
res = queue[num]
queue.remove(res)
return res
else:
print("неправильная дисциплина для getNextRequest")
return None
def _fill_futures(futures: list, fetch_tasks: deque, stage: int):
actual_tasks = deque([t for t in fetch_tasks if t[2] <= datetime.now()])
while len(futures) < INDEXER_TASKS_LIMIT[stage] and len(actual_tasks) > 0:
task = actual_tasks.popleft()
fetch_tasks.remove(task)
task_type, item_id, after_time = task
if task_type==TASK_BLOCK:
coro = _process_block(item_id, fetch_tasks)
elif task_type==TASK_WALLET:
coro = _process_wallet(item_id)
else:
assert False
f = asyncio.ensure_future(coro)
f.task = (task_type, item_id, after_time)
futures.append(f)
def full_row_checker(grid: deque, solid_blocks: list):
deleted_rows = []
for index, row in enumerate(grid):
if sum(row) == 10:
deleted_rows.append(index)
for s_block in solid_blocks.copy():
if s_block.y == index:
solid_blocks.remove(s_block)
if s_block.y < index:
solid_blocks.remove(s_block)
s_block.y += 1
solid_blocks.append(s_block)
if not deleted_rows:
return ()
flash(deleted_rows)
deleted_rows.reverse()
for deleted_row in deleted_rows:
grid.remove(grid[deleted_row])
grid.appendleft([0] * 10)
def explore_graph(self, block, queue: deque, seen: dict) -> (deque, dict):
#print(f'Exploring {block.__class__}')
for in_pin in block.input_pins:
pin_uid = id(in_pin.origin)
if pin_uid not in seen:
dependency = in_pin.origin.block
if dependency in queue:
queue.remove(dependency)
queue, seen = self.explore_graph(dependency, queue, seen)
in_pin.val = seen[pin_uid]
block.function()
for out_pin in block.output_pins:
seen[id(out_pin)] = out_pin.val
for future_block in map(lambda x: x.block, out_pin.destinations):
if future_block not in queue:
queue.append(future_block)
#print(f'Explored {block.__class__}')
return queue, seen
def move_or_append(deq: deque, item):
if item in deq:
deq.remove(item)
deq.append(item)
