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, [])
