def test_location(x: int, y: int) -> bool:
input_buffer = [x, y]
def input_func() -> int:
return input_buffer.pop(0)
output_buffer = []
def output_func(value: int):
output_buffer.append(value)
run_program(memory, input_func, output_func)
output_value, = output_buffer
return {0: False, 1: True}[output_value]
def part_one(input_text):
result = run_program(input_text, [1])
output = next(result)
while True:
if output != 0:
return output
output = next(result)
def solve(data):
tiles = {}
def joystick():
while True:
print_tiles(tiles)
paddle = [p for p in tiles if tiles[p] == 3][0]
ball = [p for p in tiles if tiles[p] == 4][0]
dist = abs(paddle[1] - ball[1])
if dist == 0:
yield 0
elif ball[1] < paddle[1]:
yield -1
else:
yield 1
program = list(map(int, data.split(",")))
program[0] = 2
outputs = run_program(program, joystick)
score = 0
while True:
try:
x = next(outputs)
y = next(outputs)
tile = next(outputs)
if (y, x) == (0, -1):
score = tile
print("Score:", score)
print_tiles(tiles)
else:
tiles[(y, x)] = tile
except StopIteration:
break
print(len(tiles))
block_tiles = [(y, x) for (y, x) in tiles if tiles[(y, x)] == 2]
print(len(block_tiles))
def part_one(input_text):
max_value = 0
for phase_settings in permutations([0, 1, 2, 3, 4], 5):
value_so_far = 0
for phase_setting in phase_settings:
value_so_far = next(
run_program(input_text, [phase_setting, value_so_far]))
max_value = max(max_value, value_so_far)
return max_value
def part_two(prog):
program = list(map(int, prog.split(",")))
phases = list(range(5, 10))
max_thrust = float("-inf")
for phase_perm in permutations(phases):
loopback_thrust = 0
def amp_a_input():
yield phase_perm[0]
while True:
yield loopback_thrust
def amp_b_input():
yield phase_perm[1]
for thrust in amp_a:
yield thrust
def amp_c_input():
yield phase_perm[2]
for thrust in amp_b:
yield thrust
def amp_d_input():
yield phase_perm[3]
for thrust in amp_c:
yield thrust
def amp_e_input():
yield phase_perm[4]
for thrust in amp_d:
yield thrust
amp_a = run_program(program.copy(), amp_a_input)
amp_b = run_program(program.copy(), amp_b_input)
amp_c = run_program(program.copy(), amp_c_input)
amp_d = run_program(program.copy(), amp_d_input)
amp_e = run_program(program.copy(), amp_e_input)
for thrust in amp_e:
loopback_thrust = thrust
max_thrust = max(max_thrust, thrust)
return max_thrust
def work(net_addr):
global NAT_X, NAT_Y
og = run_program(program.copy(), create_receiver(net_addr))
while not DIE.is_set():
try:
dest_net_addr, x, y = next(og), next(og), next(og)
if dest_net_addr == 255:
with NAT_LOCK:
NAT_X, NAT_Y = x, y
continue
queues[dest_net_addr].put((x, y))
except StopIteration:
break
def main():
program = map(int, open("day17.input", "r").read().split(","))
scaffold = [chr(o) for o in run_program(program)]
print("".join(scaffold))
program = list(map(int, open("day17.input", "r").read().split(",")))
program[0] = 2
def by_hand_counting():
for function in [
"A,B,A,C,B,C,B,A,C,B",
"L,6,R,8,R,12,L,6,L,8",
"L,10,L,8,R,12",
"L,8,L,10,L,6,L,6",
"n",
]:
for c in function:
yield ord(c)
yield ord("\n")
for o in run_program(program, by_hand_counting):
pass
print(int(o))
def part_two(input_text):
max_value = 0
for phase_settings in permutations([5, 6, 7, 8, 9], 5):
value_so_far = 0
last_val = 0
a_list = [phase_settings[0], 0]
b_list = [phase_settings[1]]
c_list = [phase_settings[2]]
d_list = [phase_settings[3]]
e_list = [phase_settings[4]]
a = run_program(input_text, a_list)
b = run_program(input_text, b_list)
c = run_program(input_text, c_list)
d = run_program(input_text, d_list)
e = run_program(input_text, e_list)
i = 0
while i < 100:
b_list.append(next(a))
c_list.append(next(b))
d_list.append(next(c))
e_list.append(next(d))
value_so_far = next(e)
if type(value_so_far) == int:
last_val = value_so_far
a_list.append(value_so_far)
else:
break
i += 1
max_value = max(max_value, last_val)
return max_value
def amp(instructions, phase_settings, amp_input=None, feedback_loop=False):
if amp_input is None:
amp_input = [0]
stdin = chain([phase_settings[0]], patient_generator(amp_input))
else:
stdin = chain([phase_settings[0]], amp_input)
stdout_gen = run_program(instructions.copy(), stdin=stdin, stdout=None)
if len(phase_settings) == 1:
yield from stdout_gen
elif feedback_loop and len(phase_settings) == 5:
for out_val in amp(instructions,
phase_settings[1:],
amp_input=stdout_gen):
amp_input.append(out_val)
yield out_val
else:
yield from amp(instructions, phase_settings[1:], amp_input=stdout_gen)
def solve(data):
maze = {(0, 0): "."}
visited = {(0, 0): 0}
please_visit = set([(-1, 0), (1, 0), (0, 1), (0, -1)])
status_codes = Queue()
def movement_commands():
y, x = 0, 0
dist = 0
last_sc = None
while len(please_visit) > 0:
if (y, x) in visited:
if (y+1, x) not in visited:
y += 1
yield north
elif (y-1, x) not in visited:
y -= 1
yield south
elif (y, x+1) not in visited:
x += 1
yield east
elif (y, x-1) not in visited:
x -= 1
yield west
else:
for movement in [north, south, west, east]:
dy, dx = get_dy_dx(movement)
if (y+dy, x+dx) in visited and visited[(y+dy, x+dx)] == dist-1:
y += dy
x += dx
dist -= 1
yield movement
last_sc = status_codes.get()
break
continue
dist += 1
last_sc = status_codes.get()
visited[(y, x)] = dist
please_visit.remove((y, x))
if last_sc == sc_wall:
maze[(y, x)] = "#"
for movement in [north, south, west, east]:
dy, dx = get_dy_dx(movement)
if (y+dy, x+dx) in visited and visited[(y+dy, x+dx)] == dist-1:
y += dy
x += dx
dist -= 1
break
elif sc == sc_moved:
maze[(y, x)] = "."
for dy, dx in map(get_dy_dx, [north, south, west, east]):
if (y+dy, x+dx) not in visited:
please_visit.add((y+dy, x+dx))
elif sc == sc_goal:
maze[(y, x)] = "G"
for dy, dx in map(get_dy_dx, [north, south, west, east]):
if (y+dy, x+dx) not in visited:
please_visit.add((y+dy, x+dx))
print(f"goal at {(y, x)}")
outputs = run_program(map(int, data.split(",")), movement_commands)
for sc in outputs:
status_codes.put(sc)
maze[(0, 0)] = "S"
print_maze(maze)
if res is not None:
return res
else:
# verify that the three funcs are a valid solution
if all(isinstance(x, int) for x in new_seq):
return new_seq, funcs
# no solution was found
return None
seq, funcs = find_solution(full_seq, [[]])
final_str = ','.join('ABC'[x] for x in seq)
final_str += '\n'
final_str += '\n'.join(make_str(func) for func in funcs)
final_str += '\nn\n'
self._input_buffer = list(final_str)
def print_grid(self):
for y in range(self.height):
for x in range(self.width):
char = '#' if self.grid[(x, y)] else '.'
print(char, end='')
print()
# run the program
camera = Camera(debug=False)
memory = load_memory(sys.argv[1])
memory[0] = 2
run_program(memory, camera.input_func, camera.output_func)
INPUT_STR = """\
NOT B J
NOT C T
OR T J
AND D J
NOT A T
OR T J
OR E T
OR H T
AND T J
RUN
"""
input_buffer = [ord(char) for char in INPUT_STR]
def input_func() -> int:
value = input_buffer.pop(0)
if DEBUG:
print(chr(value), end='', flush=True)
return value
def output_func(value: int):
if value >= 128:
print(value)
elif DEBUG:
print(chr(value), end='', flush=True)
run_program(memory, input_func, output_func)
from intcode import load_program, run_program
program = load_program("./5.in")
# stdin is defined as [1] in the problem
run_program(program, [1])
#!/usr/bin/python3
from intcode import run_program
print("Part 1: ", end='')
run_program("inputs/input9.txt", infunc=lambda:1, outfunc=print)
print("Part 2: ", end='')
run_program("inputs/input9.txt", infunc=lambda:2, outfunc=print)
import sys # argv import numpy as np from game import Game from intcode import load_memory, run_program game = Game() memory = load_memory(sys.argv[1]) run_program(memory, game.input_func, game.output_func) print(np.count_nonzero(game.grid == 2))
yield ord(ch)
yield ord("\n")
yield ord("R")
yield ord("U")
yield ord("N")
yield ord("\n")
return f
if __name__ == "__main__":
instructions = ["NOT", "AND", "OR"]
xs = "ABCDEFGHIJT"
ys = ["J", "T"]
program = list(map(int, open("day21.input", "r").read().split(",")))
for length in range(16):
print("length", length)
possible_instructions = list(
map(" ".join, product(instructions, xs, ys))
for i in range(length + 1))
for jumpscript in product(*possible_instructions):
for i, o in enumerate(
run_program(program.copy(), jumpscript_guess(jumpscript))):
if o > 255:
print(jumpscript)
print(i)
print(o)
exit(0)
if i > 40:
break
def part_one(prog):
program = list(map(int, prog.split(",")))
outputs = list(run_program(program))
return outputs
#!/usr/bin/python3
from intcode import run_program
print("Part 1:")
run_program("inputs/input5.txt", infunc=lambda: 1)
print("Part 2:")
run_program("inputs/input5.txt", infunc=lambda: 5)
drop ornament
drop klein bottle
drop dark matter
drop candy cane
drop hologram
drop astrolabe
drop whirled peas
drop tambourine
take astrolabe
take tambourine
take hologram
take klein bottle
north
"""
def semi_auto_input():
for command in commands.splitlines():
print(command)
yield from map(ord, command)
yield ord("\n")
while True:
yield from map(ord, input())
yield ord("\n")
if __name__ == "__main__":
program = map(int, open("day25.input", "r").read().split(","))
for o in run_program(program, semi_auto_input):
sys.stdout.write(chr(o))
res = d if move_dir is None else move_dir
if (x2, y2) in visited:
continue
if (x2, y2) not in grid:
return res
elif grid[(x2, y2)] != '#':
queue.append((x2, y2))
visited[(x2, y2)] = res
raise RuntimeError('Everything explored')
robot = Robot(explore)
memory = load_memory(sys.argv[1])
try:
run_program(memory, robot.input_func, robot.output_func)
except RuntimeError:
pass
# perform a breadth-first search to count how far away the O2 system is
def get_dist_to_O2(grid):
queue = [(0, 0)]
visited = {(0, 0): 0}
while queue:
x, y = queue.pop(0)
distance = visited[(x, y)] + 1
for x2, y2, d in [(x + 1, y, 4), (x - 1, y, 3), (x, y + 1, 2),
(x, y - 1, 1)]:
if (x2, y2) in visited:
continue
def part_two(input_text):
return next(run_program(input_text, [5]))
import sys
from intcode import run_program
if __name__ == "__main__":
scan = {}
for y in range(50):
for x in range(50):
program = map(int, open("day19.input", "r").read().split(","))
out = run_program(program, lambda: (i for i in (x, y)))
scan[(y, x)] = next(out)
for y in range(50):
for x in range(50):
sys.stdout.write(str(scan[(y, x)]))
sys.stdout.write("\n")
print(sum(scan.values()))
def main():
real_input = list(map(int, open("day5.input").read().strip().split(",")))
result = run_program(real_input)
