with open('input') as program:
computer = IntCode(program.read().split(','))
computer.memory[0] = 2
screen = Screen(autosolve=True)
value = []
while not computer.is_finished:
if len(value) == 3:
screen.add_sprite(*value)
value = []
screen.draw()
out = computer.run()
if out is StopIteration:
while True:
char = screen.read_input().lower()
try:
joystick = {'s': 0, 'a': -1, 'd': 1}[char]
break
except KeyError:
pass
computer.send(joystick)
else:
value.append(out)
curses.endwin()
print(screen.score)
class ASCII:
"""
Aft Scaffolding Control and Information Interface
"""
def __init__(self, software):
self.program = IntCode(software)
self.map = []
self.mapstring = ""
self.intersections = []
def build_map(self):
"""
Builds a map from the ASCII output of the IntCode program. Assigns
results to a map of characters as well as a single string.
"""
output = self.program.run()
while output[-1] == 10:
output.pop()
output.reverse()
self.map.append([])
maprow = 0
while len(output) > 0:
char = chr(output.pop())
self.mapstring += char
if char == "\n":
self.map.append([])
maprow += 1
else:
self.map[maprow].append(char)
def _is_intersection(self, xpos, ypos):
"""
Check the neighbors of the XY position and return the number of
neighbors that are a scaffold space.
"""
results = 0
for xshift, yshift in [(-1, 0), (1, 0), (0, 1), (0, -1)]:
if self.map[ypos + yshift][xpos +
xshift] in ["#", "<", ">", "^", "v"]:
results += 1
if results == 4:
return True
else:
return False
def _get_intersections(self):
"""
Detect all the intersections on the map and populate the list with
tuples of the XY intersections.
"""
for ypos in range(1, len(self.map) - 1):
for xpos in range(1, len(self.map[0]) - 1):
if self.map[ypos][xpos] == "#":
if self._is_intersection(xpos, ypos):
self.intersections.append((xpos, ypos))
def align(self):
"""
Return the alignment parameter sum.
"""
self._get_intersections()
print(self.mapstring)
sum = 0
for x, y in self.intersections:
sum += x * y
return sum
def notify(self, routine):
"""
Primes the robot to perform the notification routine. Sets the initial
opcode bit, primes the input, and prepares for the run. The run will
return the amount of dust collected during the routine, which will
be returned by the function.
"""
self.program.opcode[0] = 2
output = self.program.run()
for line in routine:
for char in line:
self.program.add_input(ord(char))
self.program.add_input(10)
self.program.add_input(ord("n"))
self.program.add_input(10)
output = self.program.run()
result = output.pop()
return result
from sys import path
path.append(path[0] + "/..")
from intcode import IntCode
with open(path[0] + "/input.txt") as f:
program = [int(x) for x in f.read().strip().split(',')]
part1 = IntCode(program)
part1.memory[1] = 12
part1.memory[2] = 2
part1.run()
print(part1.memory[0])
def bruteForce(x, y, value):
for i in range(x):
for j in range(y):
part2 = IntCode(program)
part2.memory[1] = i
part2.memory[2] = j
part2.run()
if part2.memory[0] == value:
return 100 * i + j
print(bruteForce(100, 100, 19690720))
from sys import path
path.append(path[0] + "/..")
from intcode import IntCode
with open(path[0] + "/input.txt") as f:
program = [int(x) for x in f.read().strip().split(',')]
part1 = IntCode(program)
part1.run(1)
print(part1.output)
part2 = IntCode(program)
part2.run(2)
print(part2.output)
from sys import path
path.append(path[0] + "/..")
from intcode import IntCode
with open(path[0] + "/input.txt") as f:
program = [int(x) for x in f.read().strip().split(',')]
part1 = IntCode(program)
part1.run(1)
print(part1.output)
part2 = IntCode(program)
part2.run(5)
print(part2.output)
def run_with_replace(data, a, b):
data[1] = a
data[2] = b
m = IntCode(data, level=logging.WARNING)
m.run()
return m.ops[0]
# Read input
memory = []
with open("day21/input.txt") as f:
for line in f.readlines():
memory.extend([int(x) for x in line.split(",")])
# Part 1
# spring_prog = "OR A J\nAND B J\nAND C J\nNOT J J\nAND D J\nWALK\n"
# Part 2
spring_prog = "NOT H J\nOR C J\nAND B J\nAND A J\nNOT J J\nAND D J\nRUN\n"
output_chars = []
springbot = IntCode(memory, 0)
for ch in spring_prog:
springbot.write_input(str(ord(ch)))
springbot.run()
output = int(springbot.read_output())
while not springbot.is_halted() and output < 256:
output_chars.append(chr(output))
springbot.run()
if not springbot.is_halted():
output = int(springbot.read_output())
if output > 255:
print(f"Damage: {output}")
else:
print(f"Hull: {''.join(output_chars)}")
#!/usr/bin/env python3
from prelude import *
from collections import defaultdict, Counter
from intcode import IntCode
import logging
import networkx as nx
SAMPLE = "3,15,3,16,1002,16,10,16,1,16,15,15,4,15,99,0,0"
if __name__ == "__main__":
# part1
m0 = IntCode(SAMPLE.split(","), inputs=[4, 3, 2, 1, 0])
# m = IntCode(SAMPLE.split(","), inputs=[4])
# m2 = IntCode(SAMPLE.split(","), inputs=[3])
# m3 = IntCode(SAMPLE.split(","), inputs=[2])
# m4 = IntCode(SAMPLE.split(","), inputs=[1])
# m5 = IntCode(SAMPLE.split(","), inputs=[0])
m0.run()
# m.run()
# m2.run()
# m3.run()
# m4.run()
# m5.run()
p1 = m0.last_output()
print(f"2019 7.1 -> {p1}")
# part2
# p2 = None
# print(f"2019 7.2 -> {p2}")
return Point(curr_pos.x, curr_pos.y - 1)
if curr_dir == 1:
return Point(curr_pos.x + 1, curr_pos.y)
if curr_dir == 2:
return Point(curr_pos.x, curr_pos.y + 1)
if curr_dir == 3:
return Point(curr_pos.x - 1, curr_pos.y)
grid = defaultdict(lambda: 0)
c = IntCode(program)
curr_pos = Point(0, 0)
curr_dir = 0
while not c.halt:
output_paint, output_dir = c.run([grid[curr_pos]])
grid[curr_pos] = output_paint
curr_dir = next_dir(curr_dir, output_dir)
curr_pos = next_pos(curr_pos, curr_dir)
print("part 1")
print(len(grid))
print("part 2")
grid = defaultdict(lambda: 0)
c = IntCode(program)
curr_pos = Point(0, 0)
curr_dir = 0
grid[curr_pos] = 1
def part1(ic: IntCode):
ic[1] = 12
ic[2] = 2
ic.run()
assert ic[0] == 3058646
print(ic[0])
from intcode import IntCode
def rotate(vector, direction):
degrees = radians({'left': 90, 'right': -90}[direction])
return (int(vector[0] * cos(degrees) - vector[1] * sin(degrees)),
int(vector[0] * sin(degrees) + vector[1] * cos(degrees)))
hull = defaultdict(lambda: 0)
robotpos = (0, 0)
robotdirection = (0, 1)
computer = IntCode(stdin.read().split(','))
result = computer.run()
state = 'painting'
while not computer.is_finished:
if result is StopIteration:
colour = hull[robotpos]
computer.send(colour)
else:
if state == 'painting':
hull[robotpos] = result
state = 'turning'
elif state == 'turning':
DIRECTIONS = ('left', 'right')
robotdirection = rotate(robotdirection, DIRECTIONS[result])
robotpos = (robotpos[0] + robotdirection[0],
def navigate(program):
screen = curses.initscr()
screen.keypad(True)
curses.noecho()
curses.cbreak()
rows = 80
cols = 55
window = curses.newwin(cols, rows, 3, 10)
# Track path so that we can navigate manually
# and keep track of the path length
path = list()
path_set = set()
intcode = IntCode(program)
position = 0
world = get_world()
while True:
char = screen.getch()
screen.clear()
screen.refresh()
if char == 113:
# q, quit without saving
break
elif char == curses.KEY_RIGHT:
command = RIGHT
elif char == curses.KEY_LEFT:
command = LEFT
elif char == curses.KEY_UP:
command = UP
elif char == curses.KEY_DOWN:
command = DOWN
else:
# quit and save the current state
save_world(world)
return
position += directions[command]
screen.addstr(
2, 2, f"Position (x={int(position.real)}, y={int(position.imag)})")
output = intcode.run(command)
world[position] = items[output]
if output == 0:
# cancel forward movement if hit a wall
position -= directions[command]
else:
if position in path_set:
for pos in reversed(path):
if pos == position:
break
rem_pos = path.pop(-1)
path_set.remove(rem_pos)
else:
path.append(position)
path_set.add(position)
screen.addstr(2, 30, f"Path length = {len(path)}")
draw(window, world, position)
def part1(ic: IntCode):
ic.add_input(1)
ic.run()
assert ic.output[0] == 3241900951
def part2(ic: IntCode):
ic.add_input(2)
ic.reset()
ic.run()
assert ic.output[0] == 83089
import os
from intcode import IntCode
if __name__ == "__main__":
this_dir = os.path.dirname(os.path.abspath(__file__))
input_path = os.path.join(this_dir, "input.txt")
with open(input_path) as f:
raw_code = f.readline()
intcode = IntCode(raw_code)
print("Part 1")
print("Output = {}".format(intcode.run(1)))
print("Part 2")
print("Output = {}".format(intcode.run(5)))
from intcode import IntCode
memory = list(map(int, open('input.txt').readlines()[0].split(',')))
robot = IntCode(memory)
instructions1 = [
'NOT C J', 'NOT B T', 'OR T J', 'NOT A T', 'OR T J', 'AND D J', 'WALK', ''
]
instructions = [
'NOT C J', 'NOT B T', 'OR T J', 'NOT A T', 'OR T J', 'AND D J', 'NOT E T',
'NOT T T', 'OR H T', 'AND T J', 'RUN', ''
]
output = robot.run(inputs=map(ord, '\n'.join(instructions)))
print(output[-1])
print(''.join(map(chr, output[:-1])))
# intcode.run()
# game_data[(x_pos, y_pos)] = tile_id
# tile_count = [0] * 5
# for id in game_data.values():
# tile_count[id] += 1
# print(f"Part 1: Count of '2's = {tile_count[2]}")
# # Part 2
memory[0] = 2
intcode = IntCode(memory, 0)
# intcode.reset()
game_field = [[" " for _ in range(38)] for _ in range(38)]
intcode.run()
while not intcode.is_halted():
x_pos = int(intcode.read_output())
intcode.run()
y_pos = int(intcode.read_output())
intcode.run()
tile_id = int(intcode.read_output())
intcode.run()
# update_game_data(game_data, x_pos, y_pos, tile_id)
# draw_game_field(game_data, game_field)
if (x_pos, y_pos) == (-1, 0):
print(f"Score: {tile_id}")
else:
update_game_data(game_field, x_pos, y_pos, tile_id)
for y in range(22):
pass
else:
self.sprites[pos] = tile_id
if x > self.width:
self.width = x
if y > self.height:
self.height = y
def draw(self):
for y in range(self.height + 1):
for x in range(self.width + 1):
tile = 0
if (x, y) in self.sprites:
tile = self.sprites[(x, y)]
print(self.TILE_IDS[tile], end='')
print()
screen = Screen()
computer = IntCode(stdin.read().split(','))
screen_input = []
value = []
while not computer.is_finished:
if len(value) == 3:
screen.add_sprite(*value)
value = []
value.append(computer.run())
print(len([True for s in screen.sprites if screen.sprites[s] == 2]))
return self.position
field = defaultdict(int)
field[(0, 0)] = 1
bot = PaintingRobot()
memory = [3,8,1005,8,350,1106,0,11,0,0,0,104,1,104,0,3,8,1002,8,-1,10,101,1,10,10,4,10,1008,8,1,10,4,10,102,1,8,29,1006,0,82,1006,0,40,3,8,1002,8,-1,10,101,1,10,10,4,10,1008,8,0,10,4,10,1002,8,1,57,1,102,15,10,1,1005,14,10,1006,0,33,3,8,102,-1,8,10,101,1,10,10,4,10,1008,8,0,10,4,10,102,1,8,90,1,1008,14,10,2,3,19,10,1006,0,35,1006,0,21,3,8,102,-1,8,10,1001,10,1,10,4,10,108,1,8,10,4,10,1002,8,1,125,1,1105,11,10,2,1105,9,10,1,4,1,10,2,1,4,10,3,8,1002,8,-1,10,101,1,10,10,4,10,1008,8,0,10,4,10,101,0,8,164,1006,0,71,3,8,102,-1,8,10,101,1,10,10,4,10,1008,8,0,10,4,10,1002,8,1,189,1006,0,2,1,5,17,10,1006,0,76,1,1002,7,10,3,8,1002,8,-1,10,101,1,10,10,4,10,108,1,8,10,4,10,1001,8,0,224,1,3,5,10,3,8,1002,8,-1,10,101,1,10,10,4,10,108,1,8,10,4,10,101,0,8,250,1,1,20,10,1,102,13,10,2,101,18,10,3,8,1002,8,-1,10,101,1,10,10,4,10,108,0,8,10,4,10,102,1,8,284,2,105,0,10,1,105,20,10,3,8,1002,8,-1,10,101,1,10,10,4,10,1008,8,1,10,4,10,1002,8,1,315,1006,0,88,1,2,4,10,2,8,17,10,2,6,2,10,101,1,9,9,1007,9,1056,10,1005,10,15,99,109,672,104,0,104,1,21102,1,847069688728,1,21101,0,367,0,1106,0,471,21102,386577216404,1,1,21102,378,1,0,1105,1,471,3,10,104,0,104,1,3,10,104,0,104,0,3,10,104,0,104,1,3,10,104,0,104,1,3,10,104,0,104,0,3,10,104,0,104,1,21101,97952923867,0,1,21102,425,1,0,1106,0,471,21101,0,29033143319,1,21102,436,1,0,1105,1,471,3,10,104,0,104,0,3,10,104,0,104,0,21102,1,868410614628,1,21101,0,459,0,1105,1,471,21101,837896909672,0,1,21101,0,470,0,1105,1,471,99,109,2,22102,1,-1,1,21101,40,0,2,21102,502,1,3,21102,492,1,0,1106,0,535,109,-2,2105,1,0,0,1,0,0,1,109,2,3,10,204,-1,1001,497,498,513,4,0,1001,497,1,497,108,4,497,10,1006,10,529,1102,1,0,497,109,-2,2105,1,0,0,109,4,2101,0,-1,534,1207,-3,0,10,1006,10,552,21101,0,0,-3,22101,0,-3,1,22101,0,-2,2,21102,1,1,3,21101,571,0,0,1106,0,576,109,-4,2106,0,0,109,5,1207,-3,1,10,1006,10,599,2207,-4,-2,10,1006,10,599,21202,-4,1,-4,1105,1,667,21202,-4,1,1,21201,-3,-1,2,21202,-2,2,3,21102,1,618,0,1106,0,576,21201,1,0,-4,21101,0,1,-1,2207,-4,-2,10,1006,10,637,21102,0,1,-1,22202,-2,-1,-2,2107,0,-3,10,1006,10,659,21202,-1,1,1,21101,659,0,0,106,0,534,21202,-2,-1,-2,22201,-4,-2,-4,109,-5,2105,1,0]
computer = IntCode(memory)
output = []
inputs = None
first = True
while output != None:
output = []
output = computer.run(inputs=inputs, halt_on_output=True, halt_on_missing_input=True)
inputs = None
if output is None:
print("end")
break
elif output == "input":
color = field[bot.whereami()]
# print(bot.whereami(), color)
inputs = [color]
else:
# print(output)
if first: # paint
field[bot.whereami()] = output
first = False
else: # move
bot.rotate(output)
def part2(ic: IntCode):
ic.add_input(5)
ic.reset()
ic.run()
print(ic.output[0])
assert ic.output[0] == 513116
from intcode import IntCode
input_file = open("inputs/day13.txt")
lines = input_file.read().splitlines()
program = [int(i) for i in lines[0].split(",")]
print("part 1")
c = IntCode(program)
output = c.run([])
idx = 0
block_count = 0
while idx < len(output) - 3:
x, y, tile = output[idx: idx + 3]
idx += 3
if tile == 2:
block_count += 1
print(block_count)
print("part 2")
coined_program = program
coined_program[0] = 2
c = IntCode(program)
def part1(ic: IntCode):
ic.add_input(1)
ic.run()
print(ic.output[0])
assert ic.output[0] == 5346030
from intcode import IntCode
with open('input9.txt') as f:
ic = IntCode([int(x) for x in f.read().split(',')], in_vals=[2])
output = []
while not ic.stopped:
ic.run()
output.append(ic.output)
print(output)
class Program:
def __init__(self, raw_code):
raw_code = "2" + raw_code[1:]
self._computer = IntCode(raw_code, self._get_input, self._push_output)
def run(self):
self._inputs = self._init_inputs()
self._dust_count = 0
self._x = 0
self._y = 0
self._d = {}
self._computer.run()
self._draw(self._d)
print(f"\nDust = {self._dust_count}\n")
def _init_inputs(self):
raw = [
["A", "B", "A", "B", "C", "C", "B", "C", "B", "A"],
["R", 12, "L", 8, "R", 12],
["R", 8, "R", 6, "R", 6, "R", 8],
["R", 8, "L", 8, "R", 8, "R", 4, "R", 4],
["n"],
]
out = []
for row in raw:
for s in row:
if isinstance(s, int):
for o in str(s):
out.append(ord(o))
else:
out.append(ord(s))
out.append(ord(","))
out.pop()
out.append(ord("\n"))
return out
def _get_input(self):
nxt = self._inputs.pop(0)
return nxt
def _push_output(self, value):
if value > 128:
self._dust_count = value
return
if value == 10:
self._y -= 1
self._x = 0
else:
self._d[(self._x, self._y)] = value
self._x += 1
def _draw(self, d):
key = {i: str(chr(i)) for i in range(128)}
drawer = ConsoleDrawer(key)
drawer.draw(d)
def _get_alignment(self):
out = 0
scaffolds = set([k for k, v in self._d.items() if v == 35])
for p in scaffolds:
neighbors = self._get_neighbors(p)
if len(scaffolds.intersection(neighbors)) == 4:
x, y = p
out += x * y
return out
def _get_neighbors(self, p):
return set([
(p[0] + 1, p[1]),
(p[0] - 1, p[1]),
(p[0], p[1] + 1),
(p[0], p[1] - 1),
])
def inBeam(program, x, y):
drone = IntCode(program)
return drone.run(x, y)[-1] == 1
computer._inputs.extend(instruction)
inventory = [
'space heater',
'festive hat',
'sand',
'whirled peas',
'weather machine',
'mug',
'easter egg',
'shell',
]
floor = []
while True:
computer.run()
output = "".join(map(chr, computer._outputs))
computer._outputs.clear()
print(output, end='')
# input_command = make_instruction(input())
if 'lighter' in output:
item = random.choice(inventory)
inventory.remove(item)
floor.append(item)
input_command = make_instruction(f'drop {item}\nsouth')
elif 'heavier' in output:
item = random.choice(floor)
floor.remove(item)
def get_state(x, y):
# print(x, y)
system = IntCode(memory.copy())
return int(system.run(inputs=[x, y])[0])
def springScript(program, script):
droid = IntCode(program)
droid.run()
script = [ord(x) for x in script]
droid.run(*script)
return (droid.output[-1])
def calc_thrust(inlist, program):
A = IntCode(program, in_vals=[inlist[0], 0])
B = IntCode(program, in_vals=[inlist[1]])
C = IntCode(program, in_vals=[inlist[2]])
D = IntCode(program, in_vals=[inlist[3]])
E = IntCode(program, in_vals=[inlist[4]])
A.run()
B.input = [inlist[1], A.output]
B.run()
C.input = [inlist[2], B.output]
C.run()
D.input = [inlist[3], C.output]
D.run()
E.input = [inlist[4], D.output]
E.run()
A.input = [inlist[0], E.output]
while not E.stopped:
A.run()
B.input = [A.output]
B.run()
C.input = [B.output]
C.run()
D.input = [C.output]
D.run()
E.input = [D.output]
E.run()
A.input = [E.output]
return E.output
def boost_keycode(program, input_value):
computer = IntCode(program)
if input_value:
computer.queue_input(input_value)
computer.run()
return list(computer.output_values)
