def part1(): with open("../inputs/day17.txt") as f: pc = intcode.Computer() code = f.read().strip() pc.load_program(code) out, ascii = ascii_out() pc.set_io(out=ascii) pc.run() out = [row for row in out if len(row) != 0] #print('\n'.join(''.join(row) for row in out)) alignment = 0 for y, row in enumerate(out): for x, obj in enumerate(row): if obj == "#": i = 0 if x > 0: i += out[y][x - 1] == "#" if x < len(row) - 1: i += out[y][x + 1] == "#" if y > 0: i += out[y - 1][x] == "#" if y < len(out) - 1: i += out[y + 1][x] == "#" if i == 4: alignment += x * y print(f"Alignment: {alignment}") return out
def part2(out): with open("../inputs/day17.txt") as f: pc = intcode.Computer() code = f.read().strip() pc.load_program(code) path = create_path(out) routines = compress_path(path) compiled = compile_routines(routines) dust = 0 def in_(_): x = compiled.pop(0) print(chr(x), end="") return x def out(o): nonlocal dust if o > 256: dust = o else: print(chr(o), end="") pc.memory[0] = 2 pc.set_io(in_=in_, out=out) pc.run() print("Dust collected:", dust)
def part1(raw_input): print("Part 1") computer = intcode.Computer(raw_input) computer.generator = computer.run() print(chr(computer.generator.send(None)), end='', sep='') commands = deque([ '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', 'drop manifold', 'drop easter egg', 'drop pointer', 'drop candy cane', 'east']) while True: text = [] try: while output := next(computer.generator): text.append(chr(output)) except StopIteration: pass print(''.join(text)) command = commands.popleft() if commands else input() if command == 'exit': return for c in command: output = computer.generator.send(ord(c)) if output: print(chr(output), end='') computer.generator.send(ord('\n'))
def part1(): pc = intcode.Computer() with open(os.path.join(os.path.dirname(__file__), "../inputs/day5.txt")) as f: print("Provide '1' as input") pc.load_program(f.read().strip()) pc.run()
def solve_part_b(want_debug): a_prog, b_prog, c_prog, soln = find_solution(PART_B_PATH) input_data[0] = 2 # change to part B in_q = Queue() out_q = Queue() computer = intcode.Computer(input_data, in_q, out_q) write_str(in_q, soln) write_str(in_q, a_prog) write_str(in_q, b_prog) write_str(in_q, c_prog) write_str(in_q, 'y' if want_debug else 'n') if want_debug: computer.run_async() while not computer.stopped: grid = read_grid(out_q) os.system('clear') time.sleep(.001) print_grid(grid) else: computer.run() last_num = 0 buf = [] while not out_q.empty(): buf.append(out_q.get()) print(''.join([chr(x) for x in buf[:-1]])) print('dust collected : %d' % buf[-1])
def __init__(self, last_cmd, inp=None): self.num_outputs = [] istream = sys.stdin if inp is not None: istream = StringIO.StringIO(inp) self.q = EchoQueue(last_cmd, istream, sys.stdout, self.num_outputs) self.computer = intcode.Computer("day21.data", self.q, self.q)
def part2(raw_input): print("Part 2") maximum = float('-inf') phase_permutations = itertools.permutations(range(5, 10), 5) for phase_settings in phase_permutations: computers = [] num_amplifiers = len(phase_settings) outputs = [0] * num_amplifiers for i in range(num_amplifiers): computers.append(intcode.Computer(raw_input)) computers[i].generator = computers[i].run() computers[i].generator.send(None) computers[i].generator.send(phase_settings[i]) flag = True while flag: for i in range(num_amplifiers): try: outputs[i] = computers[i].generator.send(outputs[(i - 1) % 5]) next(computers[i].generator) except StopIteration: flag = False continue maximum = max(maximum, outputs[-1]) return maximum
def part1(): pc = intcode.Computer() with open(os.path.join(os.path.dirname(__file__), "../inputs/day11.txt")) as f: prog = f.read().strip() painting = True painted = {} x, y = 0, 0 dir = 0 def camera(_): return painted.get((x, y), 0) def paint_or_turn(o): nonlocal painting, x, y, dir assert o == 0 or o == 1 if painting: painted[x, y] = o else: if o == 0: dir = (dir - 1) % 4 else: dir = (dir + 1) % 4 if dir == 0: y += 1 elif dir == 1: x += 1 elif dir == 2: y -= 1 elif dir == 3: x -= 1 painting = not painting pc.set_io(in_=camera, out=paint_or_turn) pc.load_program(prog) pc.run() print(len(painted.keys()))
def part2(): pc = intcode.Computer() with open(os.path.join(os.path.dirname(__file__), "../inputs/day13.txt")) as f: prog = f.read().strip() pc.load_program(prog) ball_pos = 0 paddle_pos = 0 score = -1 screen = {} def joystick(_): if ball_pos < paddle_pos: return -1 elif ball_pos > paddle_pos: return 1 else: return 0 def draw_tile(x, y, id): nonlocal score, paddle_pos, ball_pos x, y, id = map(int, (x, y, id)) if x == -1 and y == 0: score = int(id) if id == PADDLE: paddle_pos = int(x) elif id == BALL: ball_pos = int(x) screen[int(x), int(y)] = id pc.set_io(in_=joystick, out=intcode.out_every(3, draw_tile)) pc.memory[0] = 2 pc.run() print(score)
def calc_thruster_signal(software, phase_settings): last_output = 0 for p in phase_settings: amp = intcode.Computer(software, inputs=[p, last_output]) assert len(amp.outputs) == 1 last_output = amp.outputs[0] return last_output
def part1(): pc = intcode.Computer() with open(os.path.join(os.path.dirname(__file__), "../inputs/day9.txt")) as f: prog = f.read().strip() pc.load_program(prog) pc.set_io(in_=lambda _: 1) pc.run()
def sandbox(): print("first program:") c = intcode.Computer([ 109, 1, 204, -1, 1001, 100, 1, 100, 1008, 100, 16, 101, 1006, 101, 0, 99 ]) for o in c.run([]): print(o, end=",") print("\n") print("second program:") c = intcode.Computer([1102, 34915192, 34915192, 7, 4, 7, 99, 0]) for o in c.run([]): print(o) print(f"length of o: {len(str(o))} (should be 16)") print("third program:") c = intcode.Computer([104, 1125899906842624, 99]) for o in c.run([]): print(f"this should be 1125899906842624: {o}")
def part1(raw_input): print("Part 1") computer = intcode.Computer(raw_input) computer.set_memory(1, 12) computer.set_memory(2, 2) computer.generator = computer.run() for _ in computer.generator: pass return computer.get_memory(0)
def part1(): pc = intcode.Computer() with open(os.path.join(os.path.dirname(__file__), "../inputs/day2.txt")) as f: pc.load_program(f.read().strip()) pc.memory[1] = 12 pc.memory[2] = 2 print(pc.memory) pc.run() return pc.memory[0]
def test_02(): pc = intcode.Computer([1, 0, 0, 0, 99]) pc.run() assert pc.data.toList() == [2, 0, 0, 0, 99] pc.reset(vals=[2, 3, 0, 3, 99]), pc.run() assert pc.data.toList() == [2, 3, 0, 6, 99] pc.reset(vals=[2, 4, 4, 5, 99, 0]), pc.run() assert pc.data.toList() == [2, 4, 4, 5, 99, 9801] pc.reset(vals=[1, 1, 1, 4, 99, 5, 6, 0, 99]), pc.run() assert pc.data.toList() == [30, 1, 1, 4, 2, 5, 6, 0, 99]
def part1(raw_input): print("Part 1") computer = intcode.Computer(raw_input) computer.generator = computer.run() computer.generator.send(None) computer.generator.send(1) outputs = [] for output in computer.generator: outputs.append(output) return outputs[-1]
def part2(raw_input): print("Part 2") for noun in range(0, 100): for verb in range(0, 100): computer = intcode.Computer(raw_input) computer.set_memory(1, noun) computer.set_memory(2, verb) computer.generator = computer.run() for _ in computer.generator: pass if computer.get_memory(0) == 19690720: return 100 * noun + verb
def part2(): pc = intcode.Computer() with open(os.path.join(os.path.dirname(__file__), "../inputs/day2.txt")) as f: program = f.read().strip() for i in range(0, 100): for j in range(0, 100): pc.load_program(program) pc.memory[1] = i pc.memory[2] = j pc.run() if pc.memory[0] == 19690720: return 100 * i + j return "Error!"
def __init__(self, input_program): self.in_q = Queue() self.out_q = Queue() self.computer = intcode.Computer(input_program, self.in_q, self.out_q) self.computer_thread = threading.Thread(target=self.computer.run) self.computer_thread.daemon = True self.computer_thread.start() self.coords = (0, 0) self.grid = {} self._set_grid_value(self.coords, '.') self.oxygen_coords = None
def part1(): pc = intcode.Computer() with open(os.path.join(os.path.dirname(__file__), "../inputs/day13.txt")) as f: prog = f.read().strip() pc.load_program(prog) screen = {} def draw_tile(x, y, id): screen[int(x), int(y)] = id pc.set_io(out=intcode.out_every(3, draw_tile)) pc.run() print(sum(1 for x in screen.values() if x == BLOCK))
def part2(): bgcolor("black") pensize(10) delay(0) speed(0) penup() seth(90) goto(-420, 75) dot(10) pc = intcode.Computer() with open(os.path.join(os.path.dirname(__file__), "../inputs/day11.txt")) as f: prog = f.read().strip() painting = True painted = {(0, 0): 1} x, y = 0, 0 dir = 0 def camera(_): nonlocal painted return painted.get((x, y), 0) def paint_or_turn(o): nonlocal painting, x, y, dir if painting: painted[x, y] = o if o == 0: color("black") else: color("white") else: if o == 0: dir = (dir - 1) % 4 left(90) else: dir = (dir + 1) % 4 right(90) if dir == 0: y += 1 elif dir == 1: x += 1 elif dir == 2: y -= 1 elif dir == 3: x -= 1 dot(20) forward(20) painting = not painting pc.set_io(in_=camera, out=paint_or_turn) pc.load_program(prog) pc.run() print(len(painted.keys())) done()
def part1(raw_input): print("Part 1") maximum = float('-inf') phase_permutations = itertools.permutations(range(5), 5) for phase_settings in phase_permutations: num_amplifiers = len(phase_settings) output = 0 for i in range(num_amplifiers): computer = intcode.Computer(raw_input) computer.generator = computer.run() computer.generator.send(None) computer.generator.send(phase_settings[i]) output = computer.generator.send(output) maximum = max(maximum, output) return maximum
def calc_thruster_signal_feedback(software, phase_settings): inputs = [[p] for p in phase_settings] inputs[0].append(0) computers = [ intcode.Computer(software, inputs=i, run=False) for i in inputs ] last = computers[-1] while computers: c = computers.pop(0) done = c.run(partial=True) if len(computers) > 0: computers[0].inputs.append(c.outputs[-1]) if not done: computers.append(c) return last.outputs[-1]
def check_coords(x, y): QueueFactory = intcode.SimpleQueue in_q = QueueFactory() in_q.put(x) in_q.put(y) out_q = QueueFactory() drone = intcode.Computer(_cached_tape, in_q, out_q) drone.run() out = out_q.get() if out == 1: return '#' elif out == 0: return '.' else: raise Exception('bad output: %s' % out)
def playground(): q = CommandQueue() initial = [] #initial = ['west', 'west', 'west'] # Take all things and go to checkpoint. initial = [ 'MUTE', 'west', 'take cake', 'east', 'south', 'take coin', 'south', 'west', 'north', 'north', 'north', 'inv', 'drop cake', 'north', 'drop coin', 'north', 'take cake', 'take coin', 'north', 's', 'south', 'south', 'east', 'inv', 'north', 'east', 'take mouse', 'south', 'south', 'take hypercube', 'north', 'south', 'inv', 'north', 'north', 'west', 'north', 'north', 'south', 'west', 'west', 'take pointer', 'west', 'south', 'north', 'east', 'south', 'take monolith', 'north', 'south', 'north', 'west', 'south', 'inv', 'take tambourine', 'east', 'south', 'north', 'south', 'north', 'east', 'east', 'take mug', 'west', 'west', 'west', 'north', 'east', 'east', 'east', 'south', 'south', 'west', 'north', 'north', 'UNMUTE', 'north', 'inv' ] ITEMS = [ 'pointer', 'hypercube', 'cake', 'tambourine', 'monolith', 'mouse', 'coin', 'mug' ] def _append_recursive_tries(items, initial): if not items: initial.append('inv') initial.append('north') return this_item = items.pop() initial.append('take %s' % this_item) _append_recursive_tries(items, initial) initial.append('drop %s' % this_item) _append_recursive_tries(items, initial) items.append(this_item) _append_recursive_tries(list(ITEMS), initial) for c in initial: q.commands.append(c) try: computer = intcode.Computer('day25.data', q, q) computer.run() except KeyboardInterrupt, EOFError: pass
def part1(): robot = Robot(it.Computer(list(program), output_mode="return")) i = 0 while robot.step(): print(f"robot is walking... step {i}", end="\r") i += 1 print(f"\n\nstep1 : robot painted {len(robot.grid.keys())} panels") print( f"will need an image of {robot.maxX - robot.minX} width x {robot.maxY - robot.minY} height" ) imgFile = Image.new( "1", (robot.maxX - robot.minX + 40, robot.maxY - robot.minY + 60)) for coords in robot.grid.keys(): if robot.grid[coords] == 0: continue imgFile.putpixel((coords[0] - robot.minX + 2, robot.maxY - coords[1] - robot.minY - 3), 1) imgFile.show()
def part1(): computers = [] network = Network() for i in range(2, 3): print(f"booting computer {i}") c = it.Computer(list(program)) print(sum(c.program)) print(c.rb) print(c.i) print(f"setting network address") r1 = c.run([i] + network.dequeue(i)) if r1 != None: print(f"r1 was {r1}, get other output values") r2 = c.run([]) r3 = c.run([]) print([r1, r2, r3]) network.enqueue(r1, r2, r3) print(c.rb) print(c.i) print(sum(c.program)) computers.append(c)
def part2(raw_input): print("Part 2") computers = [] input_queues = defaultdict(deque) network_size = 50 nat = None, None last_nat_y = None for i in range(network_size): input_queues[i].append(i) computers.append(intcode.Computer(raw_input)) computers[i].generator = computers[i].run() computers[i].generator.send(None) network_idle = False while True: if network_idle: x, y = nat if y == last_nat_y: return y input_queues[0].append(x) input_queues[0].append(y) last_nat_y = y network_idle = True for i in range(network_size): network_input = input_queues[i].popleft( ) if input_queues[i] else -1 output = computers[i].generator.send(network_input) if network_input != -1: network_idle = False while output != None: address = output x = next(computers[i].generator) y = next(computers[i].generator) output = next(computers[i].generator) if address == 255: nat = x, y else: input_queues[address].append(x) input_queues[address].append(y)
def part1(raw_input): print("Part 1") computers = [] input_queues = defaultdict(deque) network_size = 50 for i in range(network_size): input_queues[i].append(i) computers.append(intcode.Computer(raw_input)) computers[i].generator = computers[i].run() computers[i].generator.send(None) while True: for i in range(network_size): network_input = input_queues[i].popleft( ) if input_queues[i] else -1 output = computers[i].generator.send(network_input) if output: x = next(computers[i].generator) y = next(computers[i].generator) input_queues[output].append(x) input_queues[output].append(y) if output == 255: return y
def find_path_for_part_b(): in_q = intcode.SimpleQueue() out_q = intcode.SimpleQueue() computer = intcode.Computer(input_data, in_q, out_q) computer.run() output = list(out_q.q) grid = read_grid(out_q) print_grid(grid) pos = (0, 10) # From looking at the grid. direction = 1 # index into DIRECTIONS, from looking at grid. path = ['R'] # must be the first thing to do. segment_length = 0 while True: front_pos = add_coords(pos, DIRECTIONS[direction]) front_sq = look(grid, front_pos) if front_sq != '.': segment_length += 1 pos = front_pos continue path.append(str(segment_length)) segment_length = 0 left_dir = (direction - 1) % 4 left_pos = add_coords(pos, DIRECTIONS[left_dir]) left_sq = look(grid, left_pos) right_dir = (direction + 1) % 4 right_pos = add_coords(pos, DIRECTIONS[right_dir]) right_sq = look(grid, right_pos) if left_sq != '.': assert right_sq == '.' direction = left_dir path.append('L') elif right_sq != '.': direction = right_dir path.append('R') else: # Reached the end. print(','.join(path)) return path