def part1(): real = list(eval(open('day13.txt').read())) pgm = Program(real) pgm.run() queue = pgm.dump() print(len(queue)) twos = [1 for k in take(queue, 3) if k[2] == 2] print("Part 1:", len(twos)) # 228
def part2(): program = Program("17") program.program[0] = 2 main = "A,B,A,B,C,B,C,A,B,C\n" a = "R,4,R,10,R,8,R,4\n" b = "R,10,R,6,R,4\n" c = "R,4,L,12,R,6,L,12\n" camera = "n\n" input_buffer = [] [input_buffer.extend(ord(c) for c in routine) for routine in [main, a, b, c, camera]] program.run(input_buffer) return program.output_buffer[-1]
def part2(): pgm = Program(real) pgm.pgm[0] = 2 instructions = ( "A,B,A,C,C,A,B,C,B,B\n", "L,8,R,10,L,8,R,8\n", "L,12,R,8,R,8\n", "L,8,R,6,R,6,R,10,L,8\n", "n\n" ) for c in ''.join(instructions): pgm.push(ord(c)) pgm.run() d = pgm.dump() if TRACE: print( Maze(d[:-1]).string ) return d[-1]
def test_sample(): programs = ( [3, 0, 4, 0, 99], [1101, 100, -1, 4, 0], [3, 9, 8, 9, 10, 9, 4, 9, 99, -1, 8], [3, 9, 7, 9, 10, 9, 4, 9, 99, -1, 8], [3, 3, 1108, -1, 8, 3, 4, 3, 99], [3, 3, 1107, -1, 8, 3, 4, 3, 99], [ 3, 21, 1008, 21, 8, 20, 1005, 20, 22, 107, 8, 21, 20, 1006, 20, 31, 1106, 0, 36, 98, 0, 0, 1002, 21, 125, 20, 4, 20, 1105, 1, 46, 104, 999, 1105, 1, 46, 1101, 1000, 1, 20, 4, 20, 1105, 1, 46, 98, 99 ], ) for prog in programs: p = Program(prog, [9]) p.run() print(p.outputs) exit(0)
def part2(): real = list(eval(open('day13.txt').read())) # Make one run to determine the limits of the grid. pgm = Program(real) pgm.run() queue = list(take(pgm.dump(), 3)) w = max(k[0] for k in queue) + 1 h = max(k[1] for k in queue) + 1 print(w, h) # Create the printable grid. grid = [] for i in range(h): grid.append([' '] * w) # Populate it from the part 1 output. for x, y, t in queue: grid[y][x] = ' #x-o'[t] display(grid) # Insert a quarter. real[0] = 2 # Go run the app. pgm = Prog13(real) pgm.grid = grid pgm.run() # Pop any unfinished output. pgm.clear_queue() display(grid) print("Part 2:", pgm.score) # 10776
def part1(): program = Program("17") program.run() x, y = (0, 0) scaffold = [] for c in program.output_buffer: print(chr(c), end='') if chr(c) == "\n": y += 1 x = 0 continue elif chr(c) in ["#", "^", "v", "<", ">"]: scaffold.append((x, y)) x += 1 intersections = [(x, y) for (x, y) in scaffold if (all(neighbour in scaffold for neighbour in [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]))] return sum([(x * y) for (x, y) in intersections])
def start_computer(address): computer = Program("23") computer.run([address]) return computer
from intcode import Program if __name__ == "__main__": total = 0 for x in range(50): for y in range(50): bot = Program("input.txt") bot.add_input(x) bot.add_input(y) bot.run() total += bot.last_output print(total)
def test_point(row, col): bot = Program("input.txt") bot.add_input(row) bot.add_input(col) bot.run() return bot.last_output
class Search: def __init__(self, inp, start = (0, 0)): self.bot = Program(inp) self.curr = start self.dirList = {self.curr: 0} self.expandList = [(0, self.curr, d, self.bot.get_state()) for d in range(len(DIRS))] self.goalPos = None def expand_next(self, sort = True): # Find closest point to expand if sort: self.expandList.sort(reverse = True, key = lambda x: x[0]) nextTile = None dist = None delta = None while (nextTile == 0 or nextTile is None) and len(self.expandList) > 0: dist, pos, delta, bot_state = self.expandList.pop() # Skip if this tile has already been expanded self.curr = (pos[0] + DIRS[delta][0], pos[1] + DIRS[delta][1]) if self.curr in self.dirList.keys(): continue self.bot.program = bot_state[2] self.bot.base = bot_state[1] self.bot.pos = bot_state[0] self.bot.input = delta + 1 # Run intcode to find response self.bot.run(stop = 4) self.bot.run(stop = 3) nextTile = self.bot.output if nextTile is not None and nextTile != 0: # Set optimal direction to get back to start self.dirList[self.curr] = DIRS[delta + (1 if delta % 2 == 0 else -1)] if nextTile == 2: # set goalpos if found self.goalPos = self.curr # Add adjascent tiles (if they haven't already been expanded) for i in range(len(DIRS)): nextPos = (self.curr[0] + DIRS[i][0], DIRS[i][1] + self.curr[1]) if nextPos not in self.dirList.keys(): self.expandList.append((dist + 1, self.curr, i, self.bot.get_state())) return nextTile def expand_front(self, limit): self.expandList.sort(reverse = True, key = lambda x: x[0]) while len(self.expandList) > 0 and self.expandList[-1][0] <= limit: expand_next(sort = false) def find_min_dist(self): # stop when list empty, or goal found while len(self.expandList) > 0: if self.expand_next() == 2: break # Backtrace to find distance dist = 0 curr = self.goalPos while curr != (0, 0): curr = (curr[0] + self.dirList[curr][0], curr[1] + self.dirList[curr][1]) dist = dist + 1 return dist def find_max_dist(self): maxDist = 0 # Explore all possible parts of the list while len(self.expandList) > 0: result = self.expand_next() if result == None or result == 0: break else: maxDist = self.expandList[-1][0] # The thinking here is that the last place to be explored will be a wall which is next to the furtherest point return maxDist
def __getitem__(self,pt): """ Allow indexing by a Point. """ if pt.x < 0 or pt.x >= self.size or pt.y < 0 or pt.y >= self.size: return '.' return self.maze[pt.y][pt.x] TRACE = 'trace' in sys.argv # Run the program once to get the path. real = list(eval(open('day17.txt').read())) pgm = Program(real) pgm.run() maze = Maze( pgm.dump() ) print(maze.string) def part1(): # Find the robot. robot = Point(maze.maze[-1].find('^'), len(maze.maze)-1) lastturn = robot # Robot starts facing north. facing = Point(0,-1) crossings = set() turns = []
from intcode import Program # solved on paper main = "A,B,A,B,C,A,B,C,A,C\n" A = "R,6,L,6,L,10\n" B = "L,8,L,6,L,10,L,6\n" C = "R,6,L,8,L,10,R,6\n" if __name__ == "__main__": camera = Program("input.txt") camera.program[0] = 2 [camera.add_input(ord(c)) for c in main] [camera.add_input(ord(c)) for c in A] [camera.add_input(ord(c)) for c in B] [camera.add_input(ord(c)) for c in C] # no camera output camera.add_input(ord("n")) camera.add_input(ord("\n")) camera.run() print(camera.get_outputs()[-1])
def inside(x, y): pgm = Program(real) pgm.push(x) pgm.push(y) pgm.run() return pgm.pop()
def solve_hard(data): p = Program(data, [5]) p.run() return p.outputs[0]
def solve_easy(data): p = Program(data, [1]) p.run() return p.outputs[-1]
from intcode import Program if __name__ == "__main__": camera = Program("input.txt") camera.run(stop = 3) grid = camera.get_outputs() gridStr = ''.join([chr(x) for x in grid]) print(gridStr) # assumes bot doesnt start on intersection gridRows = gridStr.strip().split('\n') total = 0 for row in range(1, len(gridRows) - 1): for col in range(1, len(gridRows[row]) - 1): if gridRows[row][col] == '#': if (gridRows[row + 1][col] == '#' and gridRows[row - 1][col] == '#' and gridRows[row][col - 1] == '#' and gridRows[row][col + 1] == '#'): total += row * col print(total)
def run_boost(data, input_value): p = Program(data.copy(), [input_value]) p.run() assert p.halted assert len(p.outputs) == 1 return p.outputs[0]