def collect_dust(memory, main, functions, continuous_video_feed=False):
memory[0] = 2
inputs = main + functions[0] + functions[1] + functions[2] + [121 if continuous_video_feed else 110, 10]
intcode_computer = IntcodeComputer(memory, initial_inputs=inputs)
intcode_computer.run()
return intcode_computer.get_all_outputs()
def get_linear_system_output(phase_settings, memory):
last_output = 0
for phase_setting in phase_settings:
inputs = [phase_setting, last_output]
intcode_computer = IntcodeComputer(memory, inputs)
intcode_computer.run()
last_output = intcode_computer.pop_last_output()
return last_output
def survey(commands):
inputs = functools.reduce(lambda a, b: a + string_to_ascii_array(b),
commands, [])
intcode_computer = IntcodeComputer(origin_memory, inputs)
intcode_computer.run()
output = intcode_computer.get_all_outputs()
try:
print(ascii_array_to_string(output))
except ValueError:
print(output[-1])
def test_day7_1(self):
for name, memory in [
('Day 7 test 1', self.DAY_7_MEMORY_1),
('Day 7 test 2', self.DAY_7_MEMORY_2),
('Day 7 test 3', self.DAY_7_MEMORY_3),
]:
computer = IntcodeComputer(memory)
best_phase_settings = None
best_phase_output = -99999999
initial_input = 0
for phase_settings in list(permutations([0, 1, 2, 3, 4])):
next_input = initial_input
for phase in phase_settings:
computer.reset()
next_input = computer.run(phase, next_input)
if next_input > best_phase_output:
best_phase_settings = phase_settings
best_phase_output = next_input
with self.subTest(f'{name}'):
expected_phase_setting, expected_outcome = self.DAY_7_EXPECTED_OUTCOMES[
name]
self.assertEqual(best_phase_settings, expected_phase_setting)
self.assertEqual(best_phase_output, expected_outcome)
def test_day9_1(self):
data = {
"day 9 part 1 - 1": {
'memory': [
109, 1, 204, -1, 1001, 100, 1, 100, 1008, 100, 16, 101,
1006, 101, 0, 99
],
'expected_output': [
109, 1, 204, -1, 1001, 100, 1, 100, 1008, 100, 16, 101,
1006, 101, 0, 99
]
},
"day 9 part 1 - 2": {
'memory': [1102, 34915192, 34915192, 7, 4, 7, 99, 0],
'expected_output': 1219070632396864
},
"day 9 part 1 - 3": {
'memory': [104, 1125899906842624, 99],
'expected_output': 1125899906842624
}
}
for name in data.keys():
computer = IntcodeComputer(data[name]['memory'])
test_output = computer.run()
expected_output = data[name]['expected_output']
with self.subTest(name):
self.assertEqual(expected_output, test_output)
def paint_hull(program, start_color):
computer = IntcodeComputer(program)
# NESW
direction = 0
position = (0, 0)
panel_colors = defaultdict(int)
panel_colors[position] = start_color
panels_painted = 1
def new_direction(turn_right: int):
if turn_right:
return (direction + 1) % 4
else:
return (direction - 1) % 4
while not computer.run(panel_colors[position]):
paint_color = computer.outputs[-2]
turn_right = computer.outputs[-1]
panel_colors[position] = paint_color
direction = new_direction(turn_right)
position = update_position(position, direction)
if position not in panel_colors:
panels_painted += 1
return panels_painted, panel_colors
def _run_program(computer: IntcodeComputer, output_cb: Callable[[int], None]):
it = computer.run()
try:
while True:
output = next(it)
output_cb(output)
except StopIteration:
pass
def test_day5(self):
for name, memory in [
('day5 1', self.DAY_5_MEMORY_1),
('day5 2', self.DAY_5_MEMORY_2),
]:
for initial_input in [0, 1, 2]:
with self.subTest(f'{name} input: {initial_input}'):
computer = IntcodeComputer(memory)
output_value = computer.run(initial_input)
if initial_input < 1:
self.assertEqual(initial_input, output_value)
else:
self.assertEqual(1, output_value)
def part1(puzzle_data):
all_possible_phase_settings = list(permutations([0, 1, 2, 3, 4]))
test_1 = [3, 15, 3, 16, 1002, 16, 10, 16, 1, 16, 15, 15, 4, 15, 99, 0, 0]
test_2 = [
3, 23, 3, 24, 1002, 24, 10, 24, 1002, 23, -1, 23, 101, 5, 23, 23, 1,
24, 23, 23, 4, 23, 99, 0, 0
]
test_3 = [
3, 31, 3, 32, 1002, 32, 10, 32, 1001, 31, -2, 31, 1007, 31, 0, 33,
1002, 33, 7, 33, 1, 33, 31, 31, 1, 32, 31, 31, 4, 31, 99, 0, 0, 0
]
initial_input = 0
for name, memory in [('test1', test_1), ('test2', test_2),
('test3', test_3), ('puzzle', puzzle_data)]:
computer = IntcodeComputer(memory)
best_phase_settings = None
best_phase_output = -99999999
for phase_settings in all_possible_phase_settings:
next_input = initial_input
for phase in phase_settings:
computer.reset()
computer.run(phase, next_input)
next_input = computer.output_values.pop()
if next_input > best_phase_output:
best_phase_settings = phase_settings
best_phase_output = next_input
print(name)
print(best_phase_settings)
print(best_phase_output)
print('----')
from intcode_computer import IntcodeComputer
with open("input.txt") as f:
program = [int(num) for num in f.read().strip().split(",")]
computer1 = IntcodeComputer(program)
computer1.run(1)
print("Part 1:", computer1.outputs[-1])
computer2 = IntcodeComputer(program)
computer2.run(2)
print("Part 2:", computer2.outputs[-1])
from intcode_computer import IntcodeComputer
import copy
with open("Day 9/input.txt", "r") as f:
codes = [int(i) for i in f.readline().split(",")]
comp = IntcodeComputer(optcodes=copy.deepcopy(codes), print_output=True)
comp.set_inputs(2)
comp.run()
63, 1005, 63, 545, 4, 529, 1001, 64, 1, 64, 1106, 0, 545, 1002, 64, 2, 64, 109, 12, 21102, 43, 1, -8,
1008, 1010, 43, 63, 1005, 63, 571, 4, 551, 1001, 64, 1, 64, 1106, 0, 571, 1002, 64, 2, 64, 109, -1, 1207,
-8, 27, 63, 1005, 63, 593, 4, 577, 1001, 64, 1, 64, 1106, 0, 593, 1002, 64, 2, 64, 109, -7, 21101, 44, 0,
8, 1008, 1018, 42, 63, 1005, 63, 617, 1001, 64, 1, 64, 1105, 1, 619, 4, 599, 1002, 64, 2, 64, 109, -4,
1208, -1, 39, 63, 1005, 63, 639, 1001, 64, 1, 64, 1105, 1, 641, 4, 625, 1002, 64, 2, 64, 109, 13, 2105, 1,
5, 4, 647, 1106, 0, 659, 1001, 64, 1, 64, 1002, 64, 2, 64, 109, 4, 1206, -3, 673, 4, 665, 1106, 0, 677,
1001, 64, 1, 64, 1002, 64, 2, 64, 109, -22, 21108, 45, 45, 10, 1005, 1011, 699, 4, 683, 1001, 64, 1, 64,
1105, 1, 699, 1002, 64, 2, 64, 109, 29, 2105, 1, -7, 1001, 64, 1, 64, 1105, 1, 717, 4, 705, 1002, 64, 2,
64, 109, -19, 21107, 46, 47, 5, 1005, 1016, 739, 4, 723, 1001, 64, 1, 64, 1106, 0, 739, 1002, 64, 2, 64,
109, -8, 2102, 1, 2, 63, 1008, 63, 33, 63, 1005, 63, 763, 1001, 64, 1, 64, 1106, 0, 765, 4, 745, 1002, 64,
2, 64, 109, 1, 1201, -2, 0, 63, 1008, 63, 25, 63, 1005, 63, 791, 4, 771, 1001, 64, 1, 64, 1105, 1, 791,
1002, 64, 2, 64, 109, 16, 1205, 0, 803, 1105, 1, 809, 4, 797, 1001, 64, 1, 64, 1002, 64, 2, 64, 109, -8,
1205, 9, 827, 4, 815, 1001, 64, 1, 64, 1106, 0, 827, 1002, 64, 2, 64, 109, -4, 2102, 1, -3, 63, 1008, 63,
36, 63, 1005, 63, 853, 4, 833, 1001, 64, 1, 64, 1106, 0, 853, 1002, 64, 2, 64, 109, 17, 21102, 47, 1, -6,
1008, 1019, 50, 63, 1005, 63, 877, 1001, 64, 1, 64, 1105, 1, 879, 4, 859, 1002, 64, 2, 64, 109, -29, 2107,
22, 5, 63, 1005, 63, 897, 4, 885, 1106, 0, 901, 1001, 64, 1, 64, 4, 64, 99, 21102, 27, 1, 1, 21101, 0,
915, 0, 1106, 0, 922, 21201, 1, 25338, 1, 204, 1, 99, 109, 3, 1207, -2, 3, 63, 1005, 63, 964, 21201, -2,
-1, 1, 21101, 942, 0, 0, 1105, 1, 922, 22102, 1, 1, -1, 21201, -2, -3, 1, 21102, 957, 1, 0, 1106, 0, 922,
22201, 1, -1, -2, 1105, 1, 968, 21202, -2, 1, -2, 109, -3, 2106, 0, 0]
test1 = [109, 1, 204, -1, 1001, 100, 1, 100, 1008, 100, 16, 101, 1006, 101, 0, 99]
test2 = [1102, 34915192, 34915192, 7, 4, 7, 99, 0]
test3 = [104, 1125899906842624, 99]
test4 = [109, 1, 203, 2, 204, 2, 99] # outputs the input
logging.basicConfig(level=logging.INFO)
# computer = IntcodeComputer([109, 1, 203, 2, 204, 2, 99])
computer = IntcodeComputer(puzzle)
logging.info(computer.memory)
print(computer.run(1))
from intcode_computer import IntcodeComputer
with open("input.txt") as file:
program = [int(number) for number in file.read().split(",")]
computer = IntcodeComputer()
program[1] = 12
program[2] = 2
computer.run(program)
print(f"Part 1: {computer.get_output()}")
def solve_noun_and_verb():
for noun in range(0, 99):
for verb in range(0, 99):
program[1] = noun
program[2] = verb
computer.run(program)
if computer.get_output() == 19690720:
return 100 * noun + verb
print(f"Part 2: {solve_noun_and_verb()}")
memory[0] = 2
inputs = main + functions[0] + functions[1] + functions[2] + [121 if continuous_video_feed else 110, 10]
intcode_computer = IntcodeComputer(memory, initial_inputs=inputs)
intcode_computer.run()
return intcode_computer.get_all_outputs()
with open('input.txt', 'r') as f:
origin_memory = [
int(x) for x in f.readline().split(',')
]
# Part 1
intcode_computer = IntcodeComputer(origin_memory, [])
intcode_computer.run()
camera_view = parse_camera_view(intcode_computer.get_all_outputs())
print_view(camera_view)
intersections = get_intersections(camera_view)
alignment_parameters = [
x * y for x, y in intersections
]
print(sum(alignment_parameters))
# Part 2
# Uncompressed sequence
# L,10,R,8,L,6,R,6,L,8,L,8,R,8,L,10,R,8,L,6,R,6,R,8,L,6,L,10,L,10,L,10,R,8,L,6,R,6,L,8,L,8,R,8,R,8,L6,L,10,L,10,L8,L,8,R,8,R,8,L,6,L,10,L,10,L,8,L,8,R,8
# Main sequence
class RescueBot:
def __init__(self, file_str):
self.computer = IntcodeComputer(file_str, echo=False)
self.running = False
self.rooms = {} # name(str): room(Room)
self.items = {} # name(str): room(Room)
self.directions = [] # e.g. ['north', 'west', 'west', 'south']
self.cur_room = None
self.last_room = None
self.last_dir = None
def run(self):
self.running = True
self.computer.run()
while self.running:
output = self.computer.get_output()
output = ''.join([chr(char) for char in output])
# print(output)
# Find/Create Room
self.last_room = self.cur_room
room_name = self.get_name_from_output(output)
if re.search('You can\'t go that way.', output):
print(output)
elif room_name in self.rooms:
self.cur_room = self.rooms[room_name]
else:
self.cur_room = self.get_room_from_output(output)
self.rooms[room_name] = self.cur_room
print('New Room:')
self.cur_room.print()
# print(self.cur_room.text)
# Link the rooms if they are not already
if self.last_room and self.last_room is not self.cur_room:
print('Linking: %s and %s' % (self.cur_room.name, self.last_room.name))
if self.last_room.edges[self.last_dir] is None:
self.last_room.edges[self.last_dir] = self.cur_room.name
if self.last_dir == 'north':
inv_last_dir = 'south'
elif self.last_dir == 'south':
inv_last_dir = 'north'
elif self.last_dir == 'east':
inv_last_dir = 'west'
elif self.last_dir == 'west':
inv_last_dir = 'east'
if inv_last_dir in self.cur_room.edges and self.cur_room.edges[inv_last_dir] is None:
self.cur_room.edges[inv_last_dir] = self.last_room.name
# self.cur_room.print()
# self.last_room.print()
print(output)
command = self.get_command()
print('####################')
print('Current Room: %s' % self.cur_room.name)
print('Command: %s' % command)
print('####################')
if command in ('north', 'south', 'east', 'west'):
self.last_dir = command
if command is None:
self.running = False
break
ascii_command = [ord(char) for char in command]
ascii_command.append(ord('\n'))
self.computer.read_input(ascii_command)
def get_command(self):
if self.directions:
return self.directions.pop(0)
elif self.cur_room.has_unknown_edge():
for dir, name in self.cur_room.edges.items():
if name is None:
return dir
print('Unknown Edge not found')
else:
dest = self.find_nearest_unexplored()
self.directions = self.get_directions_to_room(self.cur_room.name, dest)
if self.directions is not None:
return self.directions.pop(0)
else:
print('Directions not found')
self.running = False
return None
def find_nearest_unexplored(self):
for name, room in self.rooms.items():
print(name)
for dir, edge in room.edges.items():
if edge is None:
return name
return None
def get_directions_to_room(self, start_room, stop_room):
if start_room not in self.rooms:
print('Error: "%s" not in rooms to path.' % start_room)
return None
if stop_room not in self.rooms:
print('Error: "%s" not in rooms to path.' % stop_room)
return None
print('Finding directions from %s to %s' % (start_room, stop_room))
parents = {start_room: None}
distances = {start_room: 0}
node_list = [start_room]
while len(node_list) > 0:
node_name = node_list.pop(0)
if node_name == stop_room:
break
node_room = self.rooms[node_name]
node_edges = node_room.edges
node_dist = distances[node_name]
for dir, edge in node_edges.items():
if edge is not None and edge not in parents:
parents[edge] = (node_name, dir)
distances[edge] = node_dist + 1
node_list.append(edge)
directions = []
path_par = parents[stop_room]
while path_par is not None:
directions.insert(0, path_par[1])
path_par = parents[path_par[0]]
return directions
def get_name_from_output(self, output):
# Room Name
name_match = re.search('== ([a-zA-Z ]+) ==', output)
if name_match:
name = name_match.group(1)
# print('Room Name: %s' % name)
return name
else:
# print('Error: Name not found')
# print(output)
return None
def get_room_from_output(self, output):
new_room = Room()
new_room.text = output
# Room Name
name_match = re.search('== ([a-zA-Z ]+) ==', output)
if name_match:
name = name_match.group(1)
new_room.name = name
# print('Room Name: %s' % name)
# Adding edge rooms
dir_match = re.search('Doors here lead:\n(- north)?\n?(- east)?\n?(- south)?\n?(- west)?', output)
if dir_match:
if dir_match.group(1):
# print('north found')
new_room.edges['north'] = None
if dir_match.group(3):
# print('south found')
new_room.edges['south'] = None
if dir_match.group(2):
# print('east found')
new_room.edges['east'] = None
if dir_match.group(4):
# print('west found')
new_room.edges['west'] = None
return new_room
# Handling Items
# item_str_match = re.search('Items here:\n', output)
# if item_str_match:
# before, keyword, items = output.partition('Items here:\n')
# items_match = re.findall('- [a-z ]+', items)
# # print(items_match)
# new_room.items = items_match
# for item in items_match:
# self.items[item[2:]] = pos
def find_room_by_name(self, name):
for room in self.rooms:
if room.name == name:
return room
return None
def find_closest_unexplored_room(self):
min_dist = -1
closest = None
for pos in self.unexplored:
pos_x, pos_y = pos
dist = abs(self.x - pos_x) + abs(self.y - pos_y)
if not closest or dist < min_dist:
closest = pos
min_dist = dist
return closest
def is_being_pulled(x, y):
intcode_computer = IntcodeComputer(origin_memory, [x, y])
intcode_computer.run()
return intcode_computer.pop_last_output() == 1
def run_test(memory, input):
computer = IntcodeComputer(memory, input)
computer.run()
print('Input: {}, Output: {}'.format(input, computer.pop_last_output()))
from intcode_computer import IntcodeComputer
with open('input.txt', 'r') as f:
origin_memory = [int(x) for x in f.readline().split(',')]
# Part 1
computer = IntcodeComputer(origin_memory, [1])
computer.run()
print(computer.pop_last_output())
# Part 2
computer = IntcodeComputer(origin_memory, [2])
computer.run()
print(computer.pop_last_output())
class ScaffoldInterface:
def __init__(self, file_str=None):
self.computer = IntcodeComputer(file_str, echo=False)
def run(self):
self.computer.run()
output = self.computer.get_output_values()
self.scaffolding = [[]]
for tile in output:
if tile == 10:
self.scaffolding.append([])
# print('\n', end='')
else:
self.scaffolding[-1].append(tile)
# print(chr(tile), end='')
self.scaffolding = self.scaffolding[0:-2]
self.print_scaffolding()
self.count_intersections()
def print_scaffolding(self):
height = len(self.scaffolding)
width = len(self.scaffolding[0])
# print('%d, %d' % (width, height))
for y in range(height):
for x in range(width):
tile = self.scaffolding[y][x]
print(chr(tile), end='')
print('\n', end='')
def count_intersections(self):
height = len(self.scaffolding)
width = len(self.scaffolding[0])
intersections = []
for y in range(height):
for x in range(width):
tile = self.scaffolding[y][x]
if chr(tile) is not '#':
print('%s is not #' % tile)
continue
if y > 0 and chr(self.scaffolding[y-1][x]) is not '#':
continue
if y < height-1 and chr(self.scaffolding[y+1][x]) is not '#':
continue
if x > 0 and chr(self.scaffolding[y][x-1]) is not '#':
continue
if x < width-1 and chr(self.scaffolding[y][x+1]) is not '#':
continue
intersections.append((x, y))
intersection_alignment_sum = 0
for intersection in intersections:
intersection_alignment_sum += intersection[0] * intersection[1]
print(intersection_alignment_sum)
class ScaffoldInterface:
def __init__(self, file_str=None):
self.computer = IntcodeComputer(file_str, echo=False)
self.scaffolding = None
def run(self):
self.computer.program[0] = 2
self.computer.run()
output = self.computer.get_output_values()
self.print_output(output)
# self.save_output(output, './map.txt')
self.save_scaffolding(output)
self.find_path()
# Main Routine
routine_main = [ord(char) for char in 'A,A,B,C,B,C,B,C,B,A\n']
print('Main Len %d' % len(routine_main))
# Function A
routine_A = [ord(char) for char in 'L,10,L,8,R,8,L,8,R,6\n']
print('A Len %d' % len(routine_A))
# Function B
routine_B = [ord(char) for char in 'R,6,R,8,R,8\n']
print('B Len %d' % len(routine_B))
# Function C
routine_C = [ord(char) for char in 'R,6,R,6,L,8,L,10\n']
print('C Len %d' % len(routine_C))
# Main:
self.computer.set_input(routine_main)
print(routine_main)
self.computer.run()
output = self.computer.get_output_values()
self.print_output(output)
# Function A:
self.computer.set_input(routine_A)
print(routine_A)
self.computer.run()
output = self.computer.get_output_values()
self.print_output(output)
# Function B:
self.computer.set_input(routine_B)
print(routine_B)
self.computer.run()
output = self.computer.get_output_values()
self.print_output(output)
# Function C:
self.computer.set_input(routine_C)
print(routine_C)
self.computer.run()
output = self.computer.get_output_values()
self.print_output(output)
# Continuous Video Feed?
in_yes = [ord(char) for char in 'Y,E,S\n']
in_no = [ord(char) for char in 'N,O\n']
self.computer.set_input(in_no)
self.computer.run()
last_value = self.computer.get_last_value()
output = self.computer.get_output_values()
self.print_output(output[:-1])
print(last_value)
def save_scaffolding(self, output):
self.scaffolding = [[]]
for val in output[:-2]:
if val == ord('\n'):
self.scaffolding.append([])
else:
self.scaffolding[-1].append(chr(val))
self.scaffolding = self.scaffolding[:-2]
def find_path(self):
height = len(self.scaffolding)
width = len(self.scaffolding[0])
for y in range(height):
for x in range(width):
tile = self.scaffolding[y][x]
if tile == '^':
cur_x, cur_y = x, y
# print('%d, %d' % (cur_x, cur_y))
# Directions ^ v < >
cur_dir = '^'
path = []
print('Finding path from (%d, %d)' % (cur_x, cur_y))
while True:
# Find direction to trun
if cur_dir == '^' or cur_dir == 'v':
if cur_x > 0 and self.scaffolding[cur_y][cur_x-1] == '#':
if cur_dir == '^':
# print('L')
path.append('L')
cur_dir = '<'
else:
# print('R')
path.append('R')
cur_dir = '<'
elif cur_x < width-1 and self.scaffolding[cur_y][cur_x+1] == '#':
if cur_dir == '^':
# print('R')
path.append('R')
cur_dir = '>'
else:
# print('L')
path.append('L')
cur_dir = '>'
else:
print('Reached the end at (%d, %d) facing %s' % (cur_x, cur_y, cur_dir))
break
elif cur_dir == '<' or cur_dir == '>':
if cur_y > 0 and self.scaffolding[cur_y-1][cur_x] == '#':
if cur_dir == '<':
# print('R')
path.append('R')
cur_dir = '^'
else:
# print('L')
path.append('L')
cur_dir = '^'
elif cur_y < height-1 and self.scaffolding[cur_y+1][cur_x] == '#':
if cur_dir == '<':
# print('L')
path.append('L')
cur_dir = 'v'
else:
# print('R')
path.append('R')
cur_dir = 'v'
else:
print('Reached the end at (%d, %d) facing %s' % (cur_x, cur_y, cur_dir))
break
else:
print('Error: Invalid direction %s' % cur_dir)
# Count steps until off scaffolding
step_x, step_y = 0, 0
if cur_dir == '^':
step_y = -1
elif cur_dir == 'v':
step_y = 1
elif cur_dir == '<':
step_x = -1
elif cur_dir == '>':
step_x = 1
else:
print('Error: Invalid direction %s' % cur_dir)
distance = 0
next_tile = self.scaffolding[cur_y+step_y][cur_x+step_x]
while next_tile != '.':
distance += 1
cur_x += step_x
cur_y += step_y
if cur_x + step_x < 0 or cur_x + step_x >= width or cur_y + step_y < 0 or cur_y + step_y >= height:
next_tile = None
break
next_tile = self.scaffolding[cur_y+step_y][cur_x+step_x]
# print(distance)
path.append(distance)
print(path)
with open('./path.txt', 'w') as file:
for step in path:
file.write(str(step))
file.write(',')
def print_output(self, output):
for val in output:
print(chr(val), end='')
def save_output(self, output, file_str):
with open(file_str, 'w') as file:
for val in output:
file.write(chr(val))
from intcode_computer import IntcodeComputer
with open('input.txt', 'r') as f:
origin_memory = [
int(x) for x in f.readline().split(',')
]
# Part 1
inputs = [1]
part1_intcode_computer = IntcodeComputer(origin_memory, inputs)
part1_intcode_computer.run()
print(part1_intcode_computer.pop_last_output())
# Part 2
inputs = [5]
part2_intcode_computer = IntcodeComputer(origin_memory, inputs)
part2_intcode_computer.run()
print(part2_intcode_computer.pop_last_output())
from itertools import permutations
from intcode_computer import IntcodeComputer
with open("Day 7/input.txt", "r") as f:
codes = [int(i) for i in f.readline().split(",")]
sequences = list(permutations(range(5)))
max_val = 0
max_sequence = None
for sequence in sequences:
amp_a = IntcodeComputer(codes)
amp_a.set_inputs(sequence[0], 0)
amp_a.run()
amp_b = IntcodeComputer(codes)
amp_b.set_inputs(sequence[1], amp_a.outputs[0])
amp_b.run()
amp_c = IntcodeComputer(codes)
amp_c.set_inputs(sequence[2], amp_b.outputs[0])
amp_c.run()
amp_d = IntcodeComputer(codes)
amp_d.set_inputs(sequence[3], amp_c.outputs[0])
amp_d.run()
amp_e = IntcodeComputer(codes)
amp_e.set_inputs(sequence[4], amp_d.outputs[0])
amp_e.run()
