def get_fill_time(instructions, idx, rboffset): visited = {} # queue: (instructions, idx, rboffset, pos, pathlen) queue = [] visited[(0, 0)] = True queue.append((instructions.copy(), 0, 0, (0, 0), 0)) while len(queue) > 0: instr, idx, rboffset, pos, pathlen = queue.pop(0) for i in range(1, 5): new_pos = update_pos(pos, i) if new_pos in visited: continue else: visited[new_pos] = True new_instr = instr.copy() new_idx, new_rboffset = intcode.execute(new_instr, \ startidx=idx, \ rboffset=rboffset,\ inputdata=[i]) output = intcode.RETVAL if output == 2 or output == 0: continue elif output == 1: queue.append( (new_instr, new_idx, new_rboffset, new_pos, pathlen + 1)) return pathlen
def part1(program): out = [] intcode.execute(program, inputs=[], outputs=out) last_row, curr_row, top, res = '', '', 0, 0 while out: char = chr(out.pop(0)) if char == '\n': if top > 0: for i in range(1, len(curr_row) - 1): if [ curr_row[i], curr_row[i - 1], curr_row[i + 1], last_row[i] ].count('#') == 4: res += i * top last_row, curr_row = curr_row, '' top += 1 else: curr_row += char print(res)
def bin_search(instructions): low = 0 high = 1000 for y in range(120, 1000): while low < high: mid = (low + high) // 2 idx, rboffset = intcode.execute(instructions.copy(), \ inputdata=[i, j]) output.append(intcode.RETVAL) return -1, -1
def get_painted_positions(program, default_color): positions = {} curr_dir, curr_pos = '^', (0, 0) instr_index, rel_index, out = 0, 0, [] while instr_index < len(program): instr_index, rel_index = intcode.execute( program, inputs=[positions.get(curr_pos, default_color)], outputs=out, instr_ptr=instr_index, rel_ptr=rel_index) positions[curr_pos] = out.pop( 0) # painting the current position with the output color curr_dir, curr_pos = update_dir_and_pos(curr_dir, curr_pos, out.pop(0)) return positions
def evaluate_signal(phases): programs = [program[:] for _ in phases] instr_ptrs = [0 for _ in phases] inputs = [[phase] for phase in phases] inputs[0].append(0) i = 0 while instr_ptrs[-1] < len(programs[-1]): next_i = (i + 1) % len(phases) instr_ptrs[i], _ = intcode.execute(programs[i], inputs[i], outputs=inputs[next_i], instr_ptr=instr_ptrs[i]) i = next_i return inputs[0][-1]
def init_amplifiers(combination): initval = 0 instances = [ instructions.copy(), instructions.copy(), instructions.copy(), instructions.copy(), instructions.copy() ] idxs = [0, 0, 0, 0, 0] for i, setting in enumerate(combination): idxs[i] = intcode.execute(instances[i], idxs[i], \ [setting, initval]) initval = intcode.RETVAL return idxs, instances, initval
def part2(program): def find_symbol(s): for i in range(len(out) - 3, -1, -3): x, _, value = out[i], out[i + 1], out[i + 2] if value == s: return x def get_score(): for i in range(len(out) - 3, -1, -3): x, y, value = out[i], out[i + 1], out[i + 2] if x == -1 and y == 0: return value program[0] = 2 instr_ptr, rel_ptr, inp, out = 0, 0, [0], [] while instr_ptr < len(program): out = [] instr_ptr, rel_ptr = intcode.execute(program, inputs=inp, outputs=out) user_x, ball_x = find_symbol(3), find_symbol(4) inp.append(0 if user_x == ball_x else 1 if user_x < ball_x else -1) print(get_score())
def visit(direction_code, pos): nonlocal istr_ptr, rel_i, codes_map inp.append(direction_code) istr_ptr, rel_i = intcode.execute(program, inp, out, istr_ptr, rel_i) codes_map[pos] = out.pop(0) return codes_map[pos]
from intcode import execute instructions = [int(x) for x in open('input').read().strip().split(',')] fixed = instructions[::] fixed[1] = 12 fixed[2] = 2 # part 1 print('part 1', execute(fixed)[0]) # part 2 # replace address 1 (noun) and address 2 (verb) with something in (0,99) for noun in range(100): for verb in range(100): fixed = instructions[::] fixed[1] = noun fixed[2] = verb d = execute(fixed) if d != -1 and d[0] == 19690720: print('part 2', 100 * noun + verb)
def evaluate_signal(phases): out = [0] for phase in phases: intcode.execute(program[:], inputs=[phase, out[-1]], outputs=out) return out[-1]
# day2B # split this into a different file because I have a # hunch we'll use our intcode computer. import intcode with open("inputs/day2.txt") as f: targ = 19690720 # final number to reach for line in f: for noun in range(0,100): for verb in range(0,100): y = map(int, line.split(",")) l = list(y) l[1] = noun l[2] = verb if intcode.execute(l) == targ: print("noun: " + str(noun) + " verb: " + str(verb)) break
def combine(instructions, used): if len(used) == 5: combinations.append(used) print(used) for i in range(5): if i not in used: aux = used.copy() aux.append(i) combine(instructions.copy(), aux) if __name__ == "__main__": if len(sys.argv) != 2: print("usage: python3 amplifiers.py <instructions_file>") exit(1) instructions = intcode.load_instructions(sys.argv[1]) combine(instructions.copy(), list()) maxthrust = 0 for combination in combinations: initval = 0 for setting in combination: initval = intcode.execute(instructions.copy(), [setting, initval]) if initval > maxthrust: maxthrust = initval print("Maxthrust: ", maxthrust)
def executor(program, qi, qo): print('Running a program...') intcode.execute(program, lambda: qi.get(timeout=2), qo.put) print('Finished running a program...') qo.put(None)
import copy import itertools from intcode import execute, execute_until_output INPUT = [int(t) for t in open("day07.input").read().split(",")] # INPUT = [3,26,1001,26,-4,26,3,27,1002,27,2,27,1,27,26,27,4,27,1001,28,-1,28,1005,28,6,99,0,0,5] m = 0 for phases in itertools.permutations(range(5)): input_signal = 0 for amp in range(5): outputs = execute(INPUT, [phases[amp], input_signal]) input_signal = outputs[0] if outputs[0] > m: m = outputs[0] print m print print "part 2" m = 0 for phases in itertools.permutations(range(5, 10)): memory_a = copy.copy(INPUT) memory_b = copy.copy(INPUT) memory_c = copy.copy(INPUT) memory_d = copy.copy(INPUT) memory_e = copy.copy(INPUT)
from collections import defaultdict from intcode import execute MEMORY = defaultdict(int) INPUT = open("day09.input").read().strip().split(",") # INPUT = [1102,34915192,34915192,7,4,7,99,0] # INPUT = [104,1125899906842624,99] # INPUT = [109,1,204,-1,1001,100,1,100,1008,100,16,101,1006,101,0,99] # INPUT = [1101,0,42,1985,109,2000,109,19,204,-34,99] for idx, val in enumerate(INPUT): MEMORY[idx] = int(val) print execute(MEMORY, [1]) print execute(MEMORY, [2])
return -1, -1 if __name__ == "__main__": if len(sys.argv) != 2: print("usage: python3 tractor.py <intcode_file>") exit(1) instructions = intcode.load_instructions(sys.argv[1]) # x, y = bin_search(instructions) y = x = 1000 while True: print(x, y) idx, rboffset = intcode.execute(instructions.copy(), \ inputdata=[x, y]) if intcode.RETVAL == 0: x += 1 continue idx, rboffset = intcode.execute(instructions.copy(), \ inputdata=[x+99, y]) if intcode.RETVAL == 0: y += 1 continue idx, rboffset = intcode.execute(instructions.copy(), \ inputdata=[x, y+99]) if intcode.RETVAL == 0: x += 1 continue
if startpos != (-1, -1): break for j in range(maze.shape[1]): if maze[i][j] == '^': startpos = (i, j) break return startpos if __name__ == "__main__": if len(sys.argv) != 2: print("usage: python3 vacuum.py <instructions_file>") exit(1) instructions = intcode.load_instructions(sys.argv[1]) idx, rboffset = intcode.execute(instructions.copy()) maze = [] row = [] for c in intcode.OUTPUT: if c == 10: maze.append(row) row = [] print() else: row.append(chr(c)) print(chr(c), end='') maze.pop(-1) # remove empty row maze = np.array(maze)
if len(sys.argv) != 2: print("usage: python3 painting.py <intcode_file>") exit(1) pos = [500,500] direction = "up" painted = np.zeros((1000,1000)) panel = np.zeros((1000,1000)) instructions = intcode.load_instructions(sys.argv[1]) idx = -1 new_idx = 0 while True: intcode.OUTPUT = [] idx = new_idx new_idx = intcode.execute(instructions, startidx=idx, \ inputdata=[panel[pos[0]][pos[1]]]) if idx == new_idx: break # paint current position color = intcode.OUTPUT[0] painted[pos[0]][pos[1]] = 1 panel[pos[0]][pos[1]] = color # move to next position turn_dir = intcode.OUTPUT[1] if turn_dir == 0: direction = turn_left(direction) elif turn_dir == 1: direction = turn_right(direction)
from sys import stdin from intcode import parse, fetch, execute program = parse() print(execute((0, program)))
for i, setting in enumerate(combination): idxs[i] = intcode.execute(instances[i], idxs[i], \ [setting, initval]) initval = intcode.RETVAL return idxs, instances, initval if __name__ == "__main__": if len(sys.argv) != 2: print("usage: python3 amplifiers.py <instructions_file>") exit(1) instructions = intcode.load_instructions(sys.argv[1]) combine(instructions.copy(), list()) maxthrust = 0 for combination in combinations: idxs, instances, initval = init_amplifiers(combination) for i in cycle(range(5)): idxs[i] = intcode.execute(instances[i], idxs[i], \ [initval]) initval = intcode.RETVAL if instances[4][idxs[4]] == 99: # last amplifier halted break if initval > maxthrust: maxthrust = initval print("Maxthrust: ", maxthrust)
import sys import numpy as np import intcode if __name__ == "__main__": if len(sys.argv) != 2: print("usage: python3 tractor.py <intcode_file>") exit(1) instructions = intcode.load_instructions(sys.argv[1]) output = [] for i in range(50): for j in range(50): idx, rboffset = intcode.execute(instructions.copy(), \ inputdata=[i, j]) output.append(intcode.RETVAL) print(intcode.RETVAL, end='') print() output = np.array(output) print(output) print(output[output == 1]) print(len(output[output == 1]))
def apply(program, i, j, out): intcode.execute(program[:], inputs=[j, i], outputs=out) return out.pop(0)
def part1(program): out = [] intcode.execute(program, inputs=[], outputs=out) print(out[2::3].count(2))
else: game_data[output[i+2]].append((output[i+0], \ output[i+1])) i += 3 return game_data, game_map if __name__ == "__main__": if len(sys.argv) != 2: print("usage: python3 carepack.py <instructions_file>") exit(1) instructions = intcode.load_instructions(sys.argv[1]) instructions[0] = 2 # put 'quarters' idx, rboffset = intcode.execute(instructions, inputdata=[]) output = intcode.OUTPUT game_data, game_map = build_game_map(output) while len(game_map[game_map == 2]) > 0: move = (game_data[4][0] > game_data[3][0]) - (game_data[4][0] < game_data[3][0]) idx, rboffset = intcode.execute(instructions, \ startidx=idx, \ rboffset=rboffset,\ inputdata=[move]) output = intcode.OUTPUT game_data, game_map = build_game_map(output) print("MAX SCORE:", MAX_SCORE) print("Remaining blocks:", len(game_map[game_map == 2]))
from intcode import execute INPUT = [int(t) for t in open("day05.input").read().split(",")] execute(INPUT, [1]) execute(INPUT, [5])
# Start on a white panel panel[pos[0]][pos[1]] = 1 instructions = intcode.load_instructions(sys.argv[1]) idx = -1 new_idx = 0 rboffset = 0 while new_idx != -1: intcode.OUTPUT = [] idx = new_idx if DEBUG: print('RBOFFSET:', rboffset) new_idx, rboffset = intcode.execute(instructions, \ startidx=idx, \ rboffset=rboffset,\ inputdata=[panel[pos[0]][pos[1]]]) if new_idx == -1: # program halted break # paint current position color = intcode.OUTPUT[0] painted[pos[0]][pos[1]] = 1 panel[pos[0]][pos[1]] = int(color) if DEBUG: print('Painted', pos[0], pos[1], color) print('Turning', intcode.OUTPUT[1]) # move to next position
def part2(program): out = [] intcode.execute(program, inputs=[5], outputs=out) print(out[-1])
def part2(program, is_interactive): def starting_position(g): for i in range(len(g)): for j in range(len(g[0])): if g[i][j] in ('^', '<', '>', 'v'): return i, j # calculating the list of commands out = [] intcode.execute(program[:], inputs=[], outputs=out) grid = list(filter(len, ''.join(map(chr, out)).split('\n'))) cmd_list = find_path(grid, starting_position(grid)) # splitting up the list of commands to find the command pattern cmds = [] split(''.join(cmd_list), cmds, n=3) cmd_c, cmd_b, cmd_a = cmds cmd_m = find_pattern(cmd_list, cmds={ ''.join(cmd_a): 'A', ''.join(cmd_b): 'B', ''.join(cmd_c): 'C' }) # initialising program params program[0] = 2 out = [] if is_interactive: print('The commands to provide are {}'.format(','.join(cmd_list))) print('Main is {}'.format(','.join(cmd_m))) print('Function A is {}'.format(','.join(cmd_a))) print('Function B is {}'.format(','.join(cmd_b))) print('Function C is {}'.format(','.join(cmd_c))) instr_ptr, rel_ptr, inp = 0, 0, [] while True: out = [] instr_ptr, rel_ptr = intcode.execute(program, inputs=inp, outputs=out, instr_ptr=instr_ptr, rel_ptr=rel_ptr) if instr_ptr < len(program): inp = list(map(ord, input(''.join(map(chr, out))))) + [10] else: break else: inp = [ *list(map(ord, ','.join(cmd_m))), 10, *list(map(ord, ','.join(cmd_a))), 10, *list(map(ord, ','.join(cmd_b))), 10, *list(map(ord, ','.join(cmd_c))), 10, ord('n'), 10, ] intcode.execute(program, inputs=inp, outputs=out) print(out[-1])
import sys import numpy as np import intcode if __name__ == "__main__": if len(sys.argv) != 2: print("usage: python3 carepack.py <instructions_file>") exit(1) instructions = intcode.load_instructions(sys.argv[1]) idx, rboffset = intcode.execute(instructions) output = intcode.OUTPUT game_map = np.zeros((1000, 1000)) i = 0 while i < len(output): game_map[output[i]][output[i + 1]] = output[i + 2] i += 3 print(len(game_map[game_map == 2]))
import intcode with open("inputs/day5.txt", "r") as f: for line in f: l = intcode.process(line) intcode.execute(l, [])