def create_network_io(address: int, debug: bool = False) -> MachineIO:
machine = Machine(tape, name=f"M{address:02}", debug=debug)
io = machine.run_io()
# this is your address
io.write_single(address)
# and queue is empty
io.write_single(-1)
return io
def part_2():
tape = load_tape('data/13-program.txt')
tape[0] = 2 # 2 quarters cheat
m = Machine(tape, debug=False)
game = m.run_control()
screen = [[' ' for _ in range(SCREEN_WIDTH)] for _ in range(SCREEN_HEIGHT)]
score = None
paddle_x = None
ball_x = None
def joystick():
if paddle_x is not None and ball_x is not None:
return sgn(ball_x - paddle_x)
else:
return None
try:
while True:
x = game.send(joystick())
y = game.send(joystick())
t = game.send(joystick())
if x == -1 and y == 0:
score = t
elif 0 <= x < SCREEN_WIDTH and 0 <= y < SCREEN_HEIGHT:
prev = screen[y][x]
screen[y][x] = TILES[t]
if t == 4:
ball_x = x
elif prev == TILES[4]:
ball_x = None
if t == 3:
paddle_x = x
elif prev == TILES[3]:
paddle_x = None
if prev == TILES[2] and t != 2:
print(f"destroyed ({x}, {y})")
else:
raise ValueError(f"out of bounds: x={x}, y{y}")
if ball_x is not None and paddle_x is not None and score is not None:
print()
print(f"score: {score}")
print('\n'.join(''.join(row) for row in screen))
# time.sleep(.05)
except StopIteration:
pass
def find_noun_verb(tape, target_value) -> Optional[tuple[int, int]]:
for noun in range(len(tape)):
tape[1] = noun
for verb in range(len(tape)):
tape[2] = verb
m = Machine(tape)
assert list(m.run_output_only()) == []
value = m.memory[0]
if value == target_value:
return noun, verb
else:
return None
def find_best_phases_loop(tape: Iterable[int],
phases_range: range = range(5, 10),
debug=False):
amps = [
Machine(tape, name=f"Amp {n+1}", debug=debug)
for n in range(len(phases_range))
]
def run_amps_loop(phases: list[int]) -> Optional[int]:
amp_fs = [
amp.as_function_scalar(init=[phase])
for amp, phase in zip(amps, phases)
]
signal = 0
final_signal = None
while True:
try:
for amp_f in amp_fs:
signal = amp_f(signal)
final_signal = signal
except StopIteration:
return final_signal
best_phases = max(permutations(phases_range), key=run_amps_loop)
best_signal = run_amps_loop(best_phases)
print(f"best: {best_phases} -> {best_signal}")
return best_phases, best_signal
def part_1():
robot = Robot(Machine(load_tape('data/11-program.txt')), debug=False)
grid = defaultdict(lambda: Color.NONE)
robot.paint_on(grid)
draw_grid(grid)
count = sum(1 for color in grid.values() if color)
print(f"painted on {count} cells")
def part_1():
m = Machine(load_tape('data/13-program.txt'))
def load_screen():
seq = list(m.run_output_only())
for h in range(0, len(seq), 3):
x, y, t = seq[h:h+3]
yield Point(x, y), t
screen = list(load_screen())
draw_screen(screen)
blocks_count = sum(1 for p, t in screen if t == 2)
print(f"part 1: blocks count is {blocks_count}")
def part_2(screen):
tape = load_tape("data/17-program.txt")
assert tape[0] == 1
tape[0] = 2 # control robot
m = Machine(tape)
io = m.run_io()
script = """
A,A,B,C,B,C,B,C,A,C
R,6,L,8,R,8
R,4,R,6,R,6,R,4,R,4
L,8,R,6,L,10,L,10
"""
lines = [
line.strip() + '\n' for line in script.splitlines() if line.strip()
]
assert len(lines) == 4
draw_screen(io, screen)
io.write(lines[0]) # main
assert io.read_str() == "Function A:\n"
io.write(lines[1]) # move function A
assert io.read_str() == "Function B:\n"
io.write(lines[2]) # move function B
assert io.read_str() == "Function C:\n"
io.write(lines[3]) # move function C
assert io.read_str() == "Continuous video feed?\n"
io.write("y\n" if screen else "n\n") # video feed?
dust = draw_screen(io, screen)
print(f"dust: {dust}")
def part_1():
m = Machine(load_tape("data/17-program.txt"))
screen_output = list(m.run_output_only())
print(screen_output)
lines = [
line.strip()
for line in ''.join(chr(v) for v in screen_output).splitlines()
if line.strip()
]
height = len(lines)
width = len(lines[0])
assert all(len(line) == width for line in lines)
print(f"width={width}, height={height}")
def cross(x, y):
yield x, y
yield x + 1, y
yield x - 1, y
yield x, y + 1
yield x, y - 1
intersections = {(x, y)
for x in range(1, width - 1)
for y in range(1, height - 1)
if all(lines[cy][cx] == '#' for cx, cy in cross(x, y))}
print('\n'.join(''.join('O' if (x, y) in intersections else lines[y][x]
for x in range(width)) for y in range(height)))
alignment = sum(x * y for x, y in intersections)
print("intersections:")
for x, y in intersections:
print(f"> {x:2}, {y:2} -> {x*y:4}")
print(f"total: {alignment:5}")
def solve(fn: str):
io = Machine(load_tape(fn)).run_io()
commands = [
'west', 'take mug', 'north', 'take easter egg', 'south', 'east',
'south', 'east', 'north', 'take candy cane', 'south', 'west', 'north',
'east', 'take coin', 'north', 'north', 'take hypercube', 'south',
'east', 'take manifold', 'west', 'south', 'south', 'east',
'take pointer', 'west', 'west', 'take astrolabe', 'north', 'east',
'north'
]
items = [
command[5:] for command in commands if command.startswith('take ')
]
while commands:
print(io.read_str(), end='')
command = commands[0]
del commands[0]
print(f">>> {command}")
io.write(command + '\n')
print(io.read_str(), end='')
co = generate_commands(items)
commands = next(co)
try:
while True:
last_output = None
for command in commands:
print(f">>> {command}")
io.write(command + '\n')
last_output = io.read_str()
print(last_output, end='')
# ...
commands = co.send(int(input()))
finally:
pass
def solution(fn: str):
io = Machine(load_tape(fn)).run_io()
commands = [
'west', 'take mug', 'east', 'east', 'take coin', 'north', 'north',
'take hypercube', 'south', 'south', 'south', 'west', 'take astrolabe',
'north', 'east', 'north', 'east'
]
for command in commands:
print(io.read_str(), end='')
print(f">>> {command}")
io.write(command + "\n")
print(io.read_str(), end='')
def find_best_phases(tape: Iterable[int],
phases_range: range = range(5),
debug=False):
amps = [
Machine(tape, name=f"Amp {n+1}", debug=debug)
for n in range(len(phases_range))
]
def run_amps(phases):
signal = 0
for amp, phase in zip(amps, phases):
amp_f = amp.as_function_scalar(init=[phase])
signal = amp_f(signal)
# print(f"{phases} -> {signal}")
return signal
best_phases = max(permutations(phases_range), key=run_amps)
best_signal = run_amps(best_phases)
print(f"best: {best_phases} -> {best_signal}")
return best_phases, best_signal
def robot_run(*lines: str) -> Optional[int]:
io = Machine(load_tape("data/21-program.txt")).run_io()
print(io.read_str(), end='')
script = "".join(line + "\n" for line in lines)
print(script, end="")
io.write(script)
answer = list(io.read())
if answer[-1] > 255:
print(''.join(chr(v) for v in answer[:-1]), end="")
return answer[-1]
else:
print(''.join(chr(v) for v in answer), end="")
return None
def map_maze():
machine_f = Machine(load_tape("data/15-program.txt")).as_function_scalar()
def sensor(heading: Heading) -> Tile:
return Tile.from_code(machine_f(heading.code))
step = 0
robot = Robot(sensor)
while True:
step += 1
robot.step()
print(
f"[R] {step}: pos={robot.pos}, distance={robot.current_distance}")
if robot.current_tile == Tile.OXYGEN:
robot.draw_plan()
print(f"oxygen source located after {step} steps: "
f"pos={robot.pos}, "
f"distance={robot.current_distance}")
print()
break
# continue as different "robot"
step = 0
oxbot = Robot(sensor, pos=robot.pos)
while True:
step += 1
oxbot.step()
print(
f"[O] {step}: pos={oxbot.pos}, distance={oxbot.current_distance}")
if oxbot.current_tile == Tile.OXYGEN:
oxbot.draw_plan()
max_oxygen_distance = max(oxbot.distances.values())
print(f"max distance from oxygen source: {max_oxygen_distance}")
break
def part_1(tape: list[int]):
tape = list(tape)
tape[1], tape[2] = 12, 2
m = Machine(tape)
assert list(m.run_output_only()) == []
print(f"part 1: value at memory address 1 is {m.memory[0]}")
def __init__(self, machine: Machine, debug: bool = False):
self.brain = machine.as_function()
self.pos = Point(0, 0)
self.heading = Heading.NORTH
self.debug = debug
def part_2():
robot = Robot(Machine(load_tape('data/11-program.txt')), debug=False)
grid2 = defaultdict(lambda: Color.NONE)
grid2[Point(0, 0)] = Color.WHITE
robot.paint_on(grid2)
draw_grid(grid2)
from common.file import relative_path
from y2019.intcode import load_tape
from y2019.intcode import Machine
scan_machine = Machine(
load_tape(relative_path(__file__, "data/19-program.txt")))
scan = scan_machine.as_function_scalar(restarting=True)
def part_1():
total = 0
for y in range(50):
line = [scan(x, y) for x in range(50)]
total += sum(line)
print(''.join('#' if r else '.' for r in line))
print(f"total: {total}")
def find_square(y_start: int = 20,
x_start: tuple[int, int] = (14, 16),
square_size: int = 100,
debug: bool = False) -> tuple[int, int]:
y = y_start
x_min, x_max = x_start
assert not scan(x_min - 1, y)
assert scan(x_min, y)
assert scan(x_max, y)
assert not scan(x_max + 1, y)
xs = {y: (x_min, x_max)}
from y2019.intcode import load_tape
from y2019.intcode import Machine
if __name__ == '__main__':
m = Machine(load_tape("data/09-program.txt"))
result_1 = next(m.run_fixed_input([1]))
print(f"part 1: {result_1}")
result_2 = next(m.run_fixed_input([2]))
print(f"part 2: {result_2}")
