class Network_computer:
def __init__(self, id, queues):
self.id = id
self.computer = Intcode_computer(code, return_outputs=True)
self.computer.compute([id])
self.queues = queues
def step(self):
if not self.queues[self.id].empty():
x, y = self.queues[self.id].get(block=False)
inputs = [x,y]
else:
inputs = [-1]
outputs = self.get_output(inputs)
if outputs:
self.queues[outputs[0]].put((outputs[1], outputs[2]))
if outputs[0] == 255:
return outputs[2]
def get_output(self, input):
outputs = []
for _ in range(3):
output = self.computer.compute(input)
if not output:
return
outputs.append(output)
return outputs
def __init__(self, code):
self.score = 0
self.steps = 0
self.grid = Grid(0, {0: '.', 1: '|', 2: 'X', 3: '_', 4: 'o'})
self.engine = Intcode_computer(code)
self.last_input = 'neutral'
self.play('neutral')
class Game:
def __init__(self, code):
self.score = 0
self.steps = 0
self.grid = Grid(0, {0: '.', 1: '|', 2: 'X', 3: '_', 4: 'o'})
self.engine = Intcode_computer(code)
self.last_input = 'neutral'
self.play('neutral')
def play(self, hold):
positions = ['left', 'neutral', 'right']
input = positions.index(hold) - 1
self.last_input = hold
self.engine.compute([input])
self.parse_outputs(self.engine.outputs)
self.steps += 1
def parse_outputs(self, outputs):
i = 0
while i < len(outputs) - 2:
x, y, tile = outputs[i], outputs[i + 1], outputs[i + 2]
if x == -1:
self.score = tile
else:
self.grid.put((x, -y), tile)
if tile == 4:
self.ball = (x, y)
if tile == 3:
self.paddle = (x, y)
i += 3
def __str__(self):
return f'score: {self.score}, ball: {self.ball}, last input: {self.last_input}\n{self.grid}'
def __init__(self, code):
self.computer = Intcode_computer(code)
self.routines = {
'Main': 'A,B,A,C,A,C,B,C,C,B\n',
'A': 'L,4,L,4,L,10,R,4\n',
'B': 'R,4,L,4,L,4,R,8,R,10\n',
'C': 'R,4,L,10,R,10\n'
# 'A' : ['L','4','L','4','L','1','0','R','4'],
# 'B' : ['R','4','L','4','L','4','R','8','R','1','0' ],
# 'C' : ['R','4','L','1','0','R','1','0']
}
def run_robot(robot, intcode):
computer = Intcode_computer(intcode)
while True:
current_color = robot.read_color()
new_color = computer.compute([current_color], return_outputs=True)
new_direction = computer.compute([], return_outputs=True)
if computer.halted:
return
robot.paint(new_color)
new_direction = 'R' if new_direction else 'L'
robot.update_heading(new_direction)
robot.move()
def render_map(self):
now = time.time()
computer = Intcode_computer(self.code)
droid = Droid(computer, self.map)
self.search(droid)
print(time.time() - now)
return self.map
class Scaffold_routine:
def __init__(self, code):
self.computer = Intcode_computer(code)
self.routines = {
'Main': 'A,B,A,C,A,C,B,C,C,B\n',
'A': 'L,4,L,4,L,10,R,4\n',
'B': 'R,4,L,4,L,4,R,8,R,10\n',
'C': 'R,4,L,10,R,10\n'
# 'A' : ['L','4','L','4','L','1','0','R','4'],
# 'B' : ['R','4','L','4','L','4','R','8','R','1','0' ],
# 'C' : ['R','4','L','1','0','R','1','0']
}
def run(self):
self.computer.compute([])
self.print_ascii_output(self.computer.outputs)
self.enter_routines()
self.computer.compute([ord('n'), ord('\n')])
self.print_ascii_output(self.computer.outputs)
def enter_routines(self):
for routine in self.routines.values():
for instruction in routine:
ascii_input = [ord(instr) for instr in instruction]
self.computer.compute(ascii_input)
self.print_ascii_output(self.computer.outputs)
def print_ascii_output(self, ascii):
print(ascii[-1])
string = ''.join([chr(i) for i in ascii])
print(string)
def execute_program(program):
computer = Intcode_computer(code)
computer.compute([])
for instruction in program:
nums = string_to_nums(instruction + '\n')
computer.compute(nums)
print(nums_to_string(computer.outputs))
# https://adventofcode.com/2019/day/9
from Intcode_computer import Intcode_computer
f = open("Input09.txt")
input_string = f.read()
f.close()
code = [int(i) for i in input_string.split(',')]
# --- Part 1 ---
computer = Intcode_computer(code)
test_output = computer.compute([1], False)
print(test_output[0])
# --- Part 2 ---
computer = Intcode_computer(code)
output = computer.compute([2], False)
print(output[0])
def __init__(self, id, queues):
self.id = id
self.computer = Intcode_computer(code, return_outputs=True)
self.computer.compute([id])
self.queues = queues
def in_beam(self, x, y):
computer = Intcode_computer(self.code)
output = computer.compute([x, y], return_outputs=True)
return output == 1
def __init__(self, code):
computer = Intcode_computer(code)
computer.compute([])
self.grid = self.ascii_to_grid(computer.outputs)
import itertools
f = open("Input07.txt")
program_string = f.read()
f.close()
code = [int(i) for i in program_string.split(',')]
# --- Part 1 ---
max_output = 0
for phase in itertools.permutations(range(5)):
output = 0
for i in range(5):
amp = Intcode_computer(code)
output = amp.compute([phase[i], output])
if output > max_output:
max_output = output
print(max_output)
# --- Part 2 ---
def loop_amps(amps, output):
thruster_output = output
while True:
for i in range(5):
amp_comp = amps[i]
output = amp_comp.compute([output])
# https://adventofcode.com/2019/day/5
from Intcode_computer import Intcode_computer
f = open("Input05.txt")
program_string = f.read()
f.close()
code_chars = program_string.split(',')
code = [int(i) for i in code_chars]
# --- Part 1 ---
computer = Intcode_computer()
output = computer.compute(code, 1)
print(output[-1])
# --- Part 2 ---
computer = Intcode_computer()
output = computer.compute(code, 5)
print(output[-1])