def prints2ascii(prints, prune=True): ascii_prints = "".join(map(chr, prints)).split('\n') if prune: ascii_prints = [row for row in ascii_prints if len(row) > 0] return ascii_prints from intcode import IntCodeComputer program = list(map(int, open('data/input25').read().strip().split(','))) computer = IntCodeComputer(program, resume=True) cmds = """\ east take manifold south take whirled peas north west south take space heater south take dark matter north east north west south take antenna north east
if tile[0] == -1: score = tile[2] if tile[2] == 4: ball_pos = tile[-3:] if tile[2] == 3: paddle_pos = tile[:2] except InputInterrupt: if show: render(tiles) c.inputs.append(cmp(ball_pos[0], paddle_pos[0])) return score if __name__ == "__main__": program = list(map(int, open('inputs/day13.txt').read().split(','))) c = IntCodeComputer(program) # part 1 output = list(chunks(c.run_no_interrupt(), 3)) tile_counts = Counter([x[2] for x in output]) print(", ".join(f"{tiles_icons[k]} : {v}" for k, v in tile_counts.items())) free_play = [2] + program[1:] c = IntCodeComputer(free_play) score = play(c) print("Final Score: ", score)
def main(): args, file_in = parse_args() instructions = np.loadtxt(file_in, delimiter=',', dtype=np.int) comp = IntCodeComputer(stdin=iter([2])) print(list(comp.run(instructions)))
def test_part2(): comp = IntCodeComputer('input.txt', []) bot = PaintBot(comp, initial_color=1) bot.build_panels() # Identifier is GARPKZUL assert bot.render() == '''..##...##..###..###..#..#.####.#..#.#......
from intcode import IntCodeComputer import logging import sys logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) if __name__ == "__main__": p = [ 109, 1, 204, -1, 1001, 100, 1, 100, 1008, 100, 16, 101, 1006, 101, 0, 99 ] c = IntCodeComputer(p) assert (c.run_no_interrupt() == p) c = IntCodeComputer([1102, 34915192, 34915192, 7, 4, 7, 99, 0]) assert (len(str(c.run_no_interrupt()[0])) == 16) c = IntCodeComputer([104, 1125899906842624, 99]) assert (c.run_no_interrupt()[0] == 1125899906842624) program = list(map(int, open('inputs/day9.txt').read().split(','))) logger.info("Running BOOST test mode") c = IntCodeComputer(program, [1]) c.run_no_interrupt() print("BOOST Keycode", c.outputs[0]) logger.info("Running BOOST sensor mode") c = IntCodeComputer(program, [2]) c.run_no_interrupt() print("BOOST coordinates", c.outputs[0])
class ASCIIBot: def __init__(self, instructions): self.map = np.zeros((100, 100), dtype=np.int8) self.start = (0, 0) # row, col # instructions[0] = 1 # part 1 instructions[0] = 2 # part 2 self.input_commands = [] self.input_commands += self.movement_program() self.input_commands += [ord('n'), ord('\n')] print(self.input_commands) print([chr(x) for x in self.input_commands]) stdin = patient_generator(self.input_commands) self.computer = IntCodeComputer(stdin=stdin, stdout=None) self.computer_gen = self.computer.run(instructions) def load_camera_image(self): row_idx = 0 col_idx = 0 max_col = 0 for pixel_val in self.computer_gen: if pixel_val == 10: # new line row_idx += 1 col_idx = 0 continue if pixel_val in [ord("<"), ord(">"), ord("v"), ord("^")]: # where's the vacuum? self.start = (row_idx, col_idx) self.map[row_idx, col_idx] = pixel_val if col_idx > max_col: max_col = col_idx col_idx += 1 self.map = self.map[:row_idx - 1, :max_col + 1] def get_intersection_map(self): align_map = self.map == 35 align_map[1:, :] &= self.map[:-1, :] == 35 align_map[:-1, :] &= self.map[1:, :] == 35 align_map[:, 1:] &= self.map[:, :-1] == 35 align_map[:, :-1] &= self.map[:, 1:] == 35 return align_map def __str__(self): s = "" for row in self.map: s += "".join(chr(x) for x in row) + "\n" return s def movement_program(self): main_program = "A,A,B,C,B,C,B,C,A,C\n" func_a = """R,6,L,8,R,8\n""" func_b = """R,4,R,6,R,6,R,4,R,4\n""" func_c = """L,8,R,6,L,10,L,10\n""" # total = """ # R,6,L,8,R,8 # R,6,L,8,R,8 # # R,4,R,6,R,6,R,4,R,4, # L,8 R,6,L,10,L,10 # # R,4,R,6,R,6,R,4,R,4, # L,8,R,6,L,10,L,10 # # R,4,R,6,R,6,R,4,R,4, # L,8,R,6,L,10,L,10 # # R,6,L,8,R,8 # # L,8,R,6,L,10,L,10""" total = [] def _to_intcode(insts): for x in insts: yield ord(x) total.extend(_to_intcode(main_program)) total.extend(_to_intcode(func_a)) total.extend(_to_intcode(func_b)) total.extend(_to_intcode(func_c)) return total def walk_scaffolding(self): curr_row, curr_col = self.start move_hor = False # we check up/down first so False is OK while True: # we don't know which direction to face # and need to turn next_row, next_col = curr_row, curr_col # up if move_hor and curr_row - 1 >= 0 and self.map[curr_row - 1, curr_col] == SCAFF: next_row = curr_row - 1 turn = 'L' if self.map[curr_row, curr_col] == ord('>') else 'R' move_hor = False movement = -1 # down elif move_hor and curr_row + 1 <= self.map.shape[0] and self.map[curr_row + 1, curr_col] == SCAFF: next_row = curr_row + 1 turn = 'R' if self.map[curr_row, curr_col] == ord('>') else 'L' move_hor = False movement = 1 # left elif curr_col - 1 >= 0 and self.map[curr_row, curr_col - 1] == SCAFF: next_col = curr_col - 1 turn = 'L' if self.map[curr_row, curr_col] == ord('^') else 'R' move_hor = True movement = -1 # right elif curr_col + 1 <= self.map.shape[1] and self.map[curr_row, curr_col + 1] == SCAFF: next_col = curr_col + 1 turn = 'R' if self.map[curr_row, curr_col] == ord('^') else 'L' move_hor = True movement = 1 else: print("WE'RE DONE") break # how far do we go now while (0 <= next_row < self.map.shape[0] and 0 <= next_col < self.map.shape[1] and self.map[next_row, next_col] == SCAFF): if move_hor: next_col += movement else: next_row += movement if move_hor: next_col -= movement count = abs(next_col - curr_col) else: next_row -= movement count = abs(next_row - curr_row) print("{},{}".format(turn, count)) if move_hor: self.map[next_row, next_col] = ord("<") if movement < 0 else ord(">") else: self.map[next_row, next_col] = ord("^") if movement < 0 else ord("v") curr_row, curr_col = next_row, next_col
from intcode import IntCodeComputer droidcode = [int(x) for x in open("input.txt", "r").readline().split(",")] droid = IntCodeComputer(droidcode) def inputify(lines): output = [] for line in lines: for char in line: output.append(ord(char)) output.append(10) return output def outputify(codes): output = [] for char in codes: if 0 <= char <= 255: output.append(chr(char)) else: output.extend(outputify(inputify([str(char)]))) return "".join(output) springcode = [ "OR E J", "OR H J", "AND D J", "OR C T", "AND B T", "NOT T T", "AND T J", "NOT A T", "OR T J", "RUN" ]
def parse_result(r): out = [] for v in r[0]: try: ch = chr(v) out.append(ch) except: print('Big value: ', v) continue print(r[1]) print(''.join(out)) pc_1 = IntCodeComputer(source='input', buffered=True) program_1 = [ 'NOT A T\n', 'OR T J\n', 'NOT B T\n', 'OR T J\n', 'NOT C T\n', 'OR T J\n', # At this point, if A, B, or C is FALSE, J is TRUE. 'AND D J\n', # If the destination D is TRUE (safe), jump now. 'WALK\n', ] result = pc_1.run() parse_result(result)
def analyze_perm_2(p): pcs = [IntCodeComputer(source='input', buffered=True) for _ in range(5)] sig = 0
from itertools import permutations from intcode import IntCodeComputer amp_control = [3,8,1001,8,10,8,105,1,0,0,21,42,51,60,77,94,175,256,337,418,99999,3,9,1001,9,4,9,102,5,9,9,1001,9,3,9,102,5,9,9,4,9,99,3,9,102,2,9,9,4,9,99,3,9,1001,9,3,9,4,9,99,3,9,101,4,9,9,1002,9,4,9,101,5,9,9,4,9,99,3,9,1002,9,5,9,101,3,9,9,102,2,9,9,4,9,99,3,9,1001,9,1,9,4,9,3,9,1002,9,2,9,4,9,3,9,102,2,9,9,4,9,3,9,102,2,9,9,4,9,3,9,102,2,9,9,4,9,3,9,101,2,9,9,4,9,3,9,101,2,9,9,4,9,3,9,101,2,9,9,4,9,3,9,1001,9,1,9,4,9,3,9,101,1,9,9,4,9,99,3,9,1001,9,2,9,4,9,3,9,101,1,9,9,4,9,3,9,102,2,9,9,4,9,3,9,1001,9,1,9,4,9,3,9,101,2,9,9,4,9,3,9,1002,9,2,9,4,9,3,9,1001,9,1,9,4,9,3,9,101,1,9,9,4,9,3,9,1001,9,2,9,4,9,3,9,1002,9,2,9,4,9,99,3,9,101,2,9,9,4,9,3,9,102,2,9,9,4,9,3,9,101,2,9,9,4,9,3,9,102,2,9,9,4,9,3,9,1002,9,2,9,4,9,3,9,102,2,9,9,4,9,3,9,102,2,9,9,4,9,3,9,101,2,9,9,4,9,3,9,1001,9,2,9,4,9,3,9,101,2,9,9,4,9,99,3,9,101,2,9,9,4,9,3,9,1002,9,2,9,4,9,3,9,1001,9,1,9,4,9,3,9,101,1,9,9,4,9,3,9,1001,9,1,9,4,9,3,9,1002,9,2,9,4,9,3,9,1002,9,2,9,4,9,3,9,101,1,9,9,4,9,3,9,102,2,9,9,4,9,3,9,101,2,9,9,4,9,99,3,9,1001,9,2,9,4,9,3,9,101,2,9,9,4,9,3,9,1002,9,2,9,4,9,3,9,101,2,9,9,4,9,3,9,101,2,9,9,4,9,3,9,102,2,9,9,4,9,3,9,1002,9,2,9,4,9,3,9,102,2,9,9,4,9,3,9,1002,9,2,9,4,9,3,9,101,1,9,9,4,9,99] amp1 = IntCodeComputer(amp_control) amp2 = IntCodeComputer(amp_control) amp3 = IntCodeComputer(amp_control) amp4 = IntCodeComputer(amp_control) amp5 = IntCodeComputer(amp_control) maxres = 0 for p1, p2, p3, p4, p5 in permutations([0, 1, 2, 3, 4]): amp1 = IntCodeComputer(amp_control) result1 = amp1.run([p1, 0]) amp2 = IntCodeComputer(amp_control) result2 = amp2.run([p2, result1[0]]) amp3 = IntCodeComputer(amp_control) result3 = amp3.run([p3, result2[0]]) amp4 = IntCodeComputer(amp_control) result4 = amp4.run([p4, result3[0]]) amp5 = IntCodeComputer(amp_control) result5 = amp5.run([p5, result4[0]]) if result5[0] > maxres: maxres = result5[0] print(maxres)
import numpy as np from intcode import IntCodeComputer from collections import defaultdict moves = { 0: lambda x: (np.array((1, -1)) * x)[::-1], 1: lambda x: (np.array((-1, 1)) * x)[::-1] } if __name__ == '__main__': inputs = open('inputs.txt').read() program = [int(i) for i in inputs.split(',')] panel_colors = defaultdict(lambda: 0) panel_colors[(0, 0)] = 1 computer = IntCodeComputer(inputs, inputs=[], interactive=True) position = np.array((0, 0)) direction = np.array((0, 1)) output_list = [] while not computer.done: output = computer.run() if output == '_': computer.inputs.append(panel_colors[tuple(position)]) elif isinstance(output, int): output_list.append(output) else: # raise ValueError("Unknown output") print(output) if len(output_list) == 2: panel_colors[tuple(position)] = output_list[0] direction = moves[output_list[1]](direction) position += direction
def convert_to_ascii(s): return list(map(ord, list(s))) def parse_result(r): out = [] for v in r[0]: try: ch = chr(v) out.append(ch) except: print('Big value: ', v) continue print(r[1]) print(''.join(out)) pc = IntCodeComputer(source='input', buffered=True) result = pc.run() parse_result(result) while result[1] == 'PENDING': inp_raw = input() inp = convert_to_ascii(inp_raw + '\n') result = pc.run(inp) parse_result(result)
from intcode import IntCodeComputer if __name__ == '__main__': with open('inputs.txt') as f: inputs = f.read() computer = IntCodeComputer(inputs, inputs=[1]) print(computer.run())
from intcode import IntCodeComputer code = [int(x) for x in open("input.txt", "r").readline().split(",")] total = 0 for x in range(50): for y in range(50): droid = IntCodeComputer(code[:]) values = droid.run([x, y]) print(x, y, values) total += values[-1] print(total)
def io_put(self) -> Generator[None, PaintColor, None]: while True: raw_paint_color = yield paint_color = PaintColor(raw_paint_color) self.grid.set(self.robot.x, self.robot.y, paint_color) raw_turn_dir = yield if raw_turn_dir == 0: self.robot.turn_left() elif raw_turn_dir == 1: self.robot.turn_right() else: raise Exception(f"Unknown direction: {raw_turn_dir}") self.robot.go_forward() def __str__(self): return self.grid.render_with_robot(self.robot) with open('input.txt') as INPUT: day11_inputs = [int(i) for i in INPUT.read().split(',')] grid_and_robot = GridAndRobot() grid_and_robot.grid.set(0, 0, PaintColor.WHITE) day11_machine_state = MachineState(day11_inputs, grid_and_robot, grid_and_robot) day11_computer = IntCodeComputer(day11_machine_state) try: day11_computer.exec_program() except HaltException: print(grid_and_robot)
from intcode import IntCodeComputer # Part 1: (STDIN/STDOUT mode) pc = IntCodeComputer(source='input') pc.run() # Part 1: (Programmatic IO mode) pc = IntCodeComputer(source='input', buffered=True) result, flag = pc.run(1) print(result, flag) # Part 2: (STDIN/STDOUT mode) pc = IntCodeComputer(source='input') pc.run() # Part 2: (Programmatic IO mode) pc = IntCodeComputer(source='input', buffered=True) result, flag = pc.run(5) print(result, flag)
line.append("*") image.append("".join(line)) return "\n".join(image) infile = open("input2.txt", "r") code = [int(x) for x in infile.readline().split(",")] screen = defaultdict(int) score = 0 prevballpos = 0 ballpos = 17 balldir = 0 paddlepos = 0 game = IntCodeComputer(code) while not game.halted: print("JOYSTICK POS:", balldir) output = game.run([0]) prevballpos = ballpos for x, y, tile in divide_chunks(output, 3): if (x, y) == (-1, 0): score = tile else: screen[(x, y)] = tile if tile == 4: ballpos = x elif tile == 3:
from intcode import IntCodeComputer from collections import defaultdict import sys code = [int(x) for x in open("input.txt", "r").readline().split(",")] computers = [IntCodeComputer(code[:]) for _ in range(50)] switch = defaultdict(list) nat = (None, None) prevnat = (None, None) firstrun = True while True: idle = True for compidx, computer in enumerate(computers): if firstrun: output = computer.run([compidx, -1]) else: output = computer.run(switch[compidx] + [-1]) switch[compidx] = [] # print(compidx) for i in range(len(output) // 3): dest = output[i * 3] x = output[i * 3 + 1] y = output[i * 3 + 2] print("---", compidx, dest, x, y)
class Droid: def __init__(self, core, loc): self.computer = IntCodeComputer() self.computer.load_core(core) self.computer.state = ProgramState.running self.loc = loc self.heading = 4 self.grid_map = {self.loc: 1} # self.headings = list(next_heading[self.heading]) def move(self): self.heading = self.get_next_heading() self.computer.set_input_buffer([self.heading]) while len(self.computer.output_buffer) == 0: self.computer.step() res = self.computer.output_buffer.pop() if res != 0: self.loc = new_loc(self.loc, self.heading) if res == 2: self.grid_map[self.loc] = -2 # Oxygen else: self.grid_map[self.loc] = self.grid_map.get(self.loc, 0) + 1 # visited else: self.grid_map[new_loc(self.loc, self.heading)] = -1 # block return res def get_next_heading(self): new_heading = self.heading # Find an uncharted way for n in [0, 1, 2, 3]: _loc = new_loc(self.loc, new_heading) if _loc not in self.grid_map: return new_heading else: new_heading = turn_right[new_heading] # Find a free way that we have traveled least new_heading = self.heading min_trips, min_heading = 10000, new_heading for n in [0, 1, 2, 3]: _loc = new_loc(self.loc, new_heading) if self.grid_map[_loc] != -1: if self.grid_map[_loc] < min_trips: min_trips = self.grid_map[_loc] min_heading = new_heading new_heading = turn_right[new_heading] return min_heading def display_map(self): legend = {-2: "$", -1: "#", 1: ".", 0: " "} extent = [-20, -30, 30, 30] print(chr(27) + "[2J") print(f"h={self.heading}") for col in range(extent[0], extent[2]): print("".join( "*" if (row, col) == self.loc else legend[min(self.grid_map.get((row, col), 0), 1)] for row in range(extent[1], extent[3]))) time.sleep(.1)
def main(): computer = IntCodeComputer('day_15.input') droid = (0, 0) game_map = {droid: 3} instructions = [] not_visited = {droid: [1, 2, 3, 4]} while True: result = [] if droid in not_visited and len(not_visited[droid]) > 0: back_tracking = False instruction = not_visited[droid].pop() else: back_tracking = True if not instructions: # Done break prev = instructions.pop() if prev == 1: instruction = 2 elif prev == 2: instruction = 1 elif prev == 3: instruction = 4 elif prev == 4: instruction = 3 computer.run([instruction], result) new_pos = get_new_position(droid, instruction) if new_pos not in game_map: game_map[new_pos] = result[0] if result[0] != 0: droid = new_pos if not back_tracking: instructions.append(instruction) if droid not in not_visited: not_visited[droid] = [1, 2, 3, 4] print_map(game_map) oxygen = [x[0] for x in game_map.items() if x[1] == 2][0] graph = convert_to_graph(game_map) path = find_shortest_path(graph, (0, 0), oxygen) print(oxygen) print(path) print(len(path) - 1) max_x = max([x[0] for x in game_map]) min_x = min([x[0] for x in game_map]) max_y = max([x[1] for x in game_map]) min_y = min([x[1] for x in game_map]) longest_minimum = 0 for y in range(min_y, max_y + 1): for x in range(min_x, max_x + 1): if (x, y) in graph: longest_minimum = max( longest_minimum, len(find_shortest_path(graph, (x, y), oxygen)) - 1) print(longest_minimum)
def test_part1(): comp = IntCodeComputer('input.txt', []) bot = PaintBot(comp) bot.build_panels(debug=False) # print(bot.render()) assert len(bot.panels) == 1686
ymax = y return [xmin, xmax], [ymin, ymax] class AI: # LOL "AI" def __init__(self): self.map = Map() def move(self, result=None): return random.randint(1, 4) if __name__ == '__main__': pc = IntCodeComputer(source='input', buffered=True) i_robot = AI() result = None # LOL total garbage: for _ in range(1000000): move = i_robot.move(result) ic_out = pc.run(move) result = ic_out[0][0] update = i_robot.map.update(move, result) if update != 0: print(update) # break # print()
from functools import lru_cache import numpy as np from intcode import IntCodeComputer, IntCodeStatus program = list(map(int, open('data/input19').read().strip().split(','))) computer = IntCodeComputer(program, resume=False) coords = {} for x in range(50): for y in range(50): _, prints, status = computer.run(input_values=[x, y]) assert status == IntCodeStatus.TERMINATED coords[x + 1j * y] = prints[0] beam = np.empty((50, 50)) for c, value in coords.items(): r, c = int(c.imag), int(c.real) beam[r, c] = value print(f"solution for part1: {int(beam.sum())}") @lru_cache() def get_beam_value(r, c): x, y = c, r _, beam_value, status = computer.run(input_values=[x, y]) assert status == IntCodeStatus.TERMINATED assert len(beam_value) == 1 return beam_value[0] @lru_cache()
reverse = {NORTH: SOUTH, SOUTH: NORTH, WEST: EAST, EAST: WEST} pos = (0, 0) target = None grid = defaultdict(lambda: " ") gridnet = nx.Graph() grid[pos] = "." gridnet.add_node((0, 0)) breadcrumbs = [] complete = False droid = IntCodeComputer(code) droid.run([]) while not complete and not droid.halted: print(pos) if grid[move(pos, NORTH)] == " ": # print(f"attempting to move north from {pos}") output = droid.run([NORTH])[-1] # print(output) if output == 0: grid[move(pos, NORTH)] = "#" elif output > 0: breadcrumbs.append((reverse[NORTH], pos)) gridnet.add_node(move(pos, NORTH)) gridnet.add_edge(pos, move(pos, NORTH)) pos = move(pos, NORTH)
from collections import defaultdict import time np.set_printoptions(linewidth=220, threshold=10000) def coords_to_mem(x, y): return x * 38 + y if __name__ == '__main__': inputs = open('inputs.txt').read() program = [int(i) for i in inputs.split(',')] outputs = [] computer = IntCodeComputer(inputs, interactive=True) mem = computer.program mem[0] = 2 for i in range(1286 - 38, 1322 - 38): mem[i] = 1 # mem[1398] = 2 # mem[639] = 2 x, y = None, None pixels = np.zeros((20, 38)).astype(np.object) x_candidates = None y_candidates = None step = 0 while not computer.done: while not computer.done: outputs.append(computer.run()) if outputs[-1] == '_':
def c(self, program): return IntCodeComputer(program)
def run_robot_run(core): panel = {} pr = PaintingRobot() computer = IntCodeComputer() computer.load_core(core) computer.state = ProgramState.running while computer.state == ProgramState.running: computer.set_input_buffer([pr.camera(panel)]) inst = [None, None] while len(computer.output_buffer) == 0: computer.step() if computer.state != ProgramState.running: return len(pr._painted_panels) inst[0] = computer.output_buffer.pop() while len(computer.output_buffer) == 0: computer.step() inst[1] = computer.output_buffer.pop() pr.paint(inst[0], panel) pr.turn(inst[1])
from intcode import IntCodeComputer prog = open("input.txt", "r").readline().split(",") state = [int(x) for x in prog] compy = IntCodeComputer(state) compy.run()
from intcode import IntCodeComputer code = [int(x) for x in open("input.txt", "r").readline().split(",")] game = IntCodeComputer(code) def asciify(chars): return "".join(chr(x) for x in chars) def charify(text): return [ord(x) for x in text] + [10] line = "" while not game.halted: output = game.run(charify(line)) print(asciify(output)) line = input(">").strip() print("game halted")
709052072804, 1, 21102, 1, 481, 0, 1106, 0, 482, 99, 109, 2, 21202, -1, 1, 1, 21101, 0, 40, 2, 21101, 0, 513, 3, 21101, 503, 0, 0, 1106, 0, 546, 109, -2, 2105, 1, 0, 0, 1, 0, 0, 1, 109, 2, 3, 10, 204, -1, 1001, 508, 509, 524, 4, 0, 1001, 508, 1, 508, 108, 4, 508, 10, 1006, 10, 540, 1101, 0, 0, 508, 109, -2, 2105, 1, 0, 0, 109, 4, 1202, -1, 1, 545, 1207, -3, 0, 10, 1006, 10, 563, 21102, 0, 1, -3, 21202, -3, 1, 1, 22101, 0, -2, 2, 21102, 1, 1, 3, 21101, 582, 0, 0, 1105, 1, 587, 109, -4, 2106, 0, 0, 109, 5, 1207, -3, 1, 10, 1006, 10, 610, 2207, -4, -2, 10, 1006, 10, 610, 21202, -4, 1, -4, 1106, 0, 678, 22102, 1, -4, 1, 21201, -3, -1, 2, 21202, -2, 2, 3, 21102, 629, 1, 0, 1106, 0, 587, 22102, 1, 1, -4, 21101, 0, 1, -1, 2207, -4, -2, 10, 1006, 10, 648, 21102, 0, 1, -1, 22202, -2, -1, -2, 2107, 0, -3, 10, 1006, 10, 670, 21202, -1, 1, 1, 21101, 670, 0, 0, 105, 1, 545, 21202, -2, -1, -2, 22201, -4, -2, -4, 109, -5, 2106, 0, 0 ] brain = IntCodeComputer(code) painted = set() hull = defaultdict(int) hull[(0, 0)] = 1 direction = 0 # 0 up, 1 right, 2 down, 3 left x = 0 y = 0 while not brain.halted: result = brain.run([hull[(x, y)]]) color = result[-2] turn = result[-1] hull[(x, y)] = color painted.add((x, y))