def paint_hull(paint_bot: IntcodeComputer, ship_hull: Hull) -> Hull:
current_location = (0, 0)
heading = 0
while True:
try:
bot_input = ship_hull[current_location]
except KeyError:
bot_input = 0
paint_bot.set_inputs([bot_input])
code, color = paint_bot.execute()
if code != IntcodeComputer.RETURNING_OUTPUT:
break
ship_hull[current_location] = color
code, turn_direction = paint_bot.execute()
if code != IntcodeComputer.RETURNING_OUTPUT:
raise Exception("Should not be exiting here.")
heading = (heading + ROTATIONS[turn_direction]) % len(DIRECTIONS)
x, y, = current_location
dx, dy = DIRECTIONS[heading]
current_location = x + dx, y + dy
return ship_hull
def test_multiplication():
# position output
computer = IntcodeComputer([1102, 3, 5, 2, 99])
computer.execute()
assert computer.program[2] == 15
# relative
computer = IntcodeComputer([109, 2, 21102, 3, 5, 2, 99])
computer.execute()
assert computer.program[4] == 15
def test_equal():
# position output
computer = IntcodeComputer([1108, 3, 5, 2, 99])
computer.execute()
assert computer.program[2] == 0
# relative
computer = IntcodeComputer([109, -1, 21108, 3, 5, 3, 99])
computer.execute()
assert computer.program[2] == 0
def test_less_than():
# position output
computer = IntcodeComputer([1107, 3, 5, 2, 99])
computer.execute()
assert computer.program[2] == 1
# relative
computer = IntcodeComputer([109, -1, 21107, 3, 5, 2, 99])
computer.execute()
assert computer.program[1] == 1
def test_adjust_relative_base():
computer = IntcodeComputer()
assert computer.relative_base == 0
# immediate mode
computer = IntcodeComputer([109, 5, 99])
computer.execute()
assert computer.relative_base == 5
# position mode
computer = IntcodeComputer([9, 3, 99, -7])
computer.execute()
assert computer.relative_base == -7
def test_get_value_relative():
# base += 3 (immediate), output in relative mode
computer = IntcodeComputer([109, 3, 204, 1, 99])
code, result = computer.execute()
assert computer.relative_base == 3
assert result == 99
computer = IntcodeComputer([109, 19, 204, -34, 99] +
[n for n in range(5, 1996)])
computer.relative_base = 2000
code, result = computer.execute()
assert computer.relative_base == 2019
assert result == 1985
def part1(program: List[int]) -> int:
computer = IntcodeComputer(program, [1])
while True:
code, result = computer.execute()
if code == IntcodeComputer.RETURNING_OUTPUT:
return result
def test_less_than_position_mode():
intcode_list = [3, 9, 7, 9, 10, 9, 4, 9, 99, -1, 8]
inputs = [0, 8, 10]
expected_outputs = [1, 0, 0]
for input_value, expected_output in zip(inputs, expected_outputs):
computer = IntcodeComputer(intcode_list)
for value in computer.execute(input_value):
pass
assert value == expected_output
def test_less_than_immediate_mode():
intcode_list = [3, 3, 1107, -1, 8, 3, 4, 3, 99]
inputs = [0, 8, 10]
expected_outputs = [1, 0, 0]
for input_value, expected_output in zip(inputs, expected_outputs):
computer = IntcodeComputer(intcode_list)
for value in computer.execute(input_value):
pass
assert value == expected_output
def test_jump_position():
intcode_list = [3, 12, 6, 12, 15, 1, 13, 14, 13, 4, 13, 99, -1, 0, 1, 9]
inputs = [0, 8, 10, -5]
expected_outputs = [0, 1, 1, 1]
for input_value, expected_output in zip(inputs, expected_outputs):
computer = IntcodeComputer(intcode_list)
for value in computer.execute(input_value):
pass
assert value == expected_output
def test_jump_immediate():
intcode_list = [3, 3, 1105, -1, 9, 1101, 0, 0, 12, 4, 12, 99, 1]
inputs = [0, 8, 10, -5]
expected_outputs = [0, 1, 1, 1]
for input_value, expected_output in zip(inputs, expected_outputs):
computer = IntcodeComputer(intcode_list)
for value in computer.execute(input_value):
pass
assert value == expected_output
def part1(amp_controller_code: List[int]) -> int:
output_signals = []
for phase_setting_sequence in permutations(range(5), 5):
amp_output = 0
for setting in phase_setting_sequence:
computer = IntcodeComputer(amp_controller_code,
inputs=[setting, amp_output])
code, amp_output = computer.execute()
output_signals.append(amp_output)
return max(output_signals)
def test_large():
intcode_list = [
3, 21, 1008, 21, 8, 20, 1005, 20, 22, 107, 8, 21, 20, 1006, 20, 31,
1106, 0, 36, 98, 0, 0, 1002, 21, 125, 20, 4, 20, 1105, 1, 46, 104, 999,
1105, 1, 46, 1101, 1000, 1, 20, 4, 20, 1105, 1, 46, 98, 99
]
inputs = [0, 8, 10, -5]
expected_outputs = [999, 1000, 1001, 999]
for input_value, expected_output in zip(inputs, expected_outputs):
computer = IntcodeComputer(intcode_list)
for value in computer.execute(input_value):
pass
assert value == expected_output
def test_extra_memory():
# immediate mode, add 1 to 3, put in memory 5 (out of bounds)
computer = IntcodeComputer([1101, 1, 3, 5, 99])
computer.execute()
assert computer.program[5] == 4
computer = IntcodeComputer([
109, 1, 204, -1, 1001, 100, 1, 100, 1008, 100, 16, 101, 1006, 101, 0,
99
],
debug=True)
code = 0
while code != IntcodeComputer.HALT:
code, result = computer.execute()
computer = IntcodeComputer([1102, 34915192, 34915192, 7, 4, 7, 99, 0])
code, result = computer.execute()
assert len(str(result)) == 16
computer = IntcodeComputer([104, 1125899906842624, 99])
code, result = computer.execute()
assert result == 1125899906842624
def test_addition():
# position output
computer = IntcodeComputer([1101, 3, 5, 2, 99])
computer.execute()
assert computer.program[2] == 8
# immediate
computer = IntcodeComputer([11101, 3, 5, 2, 99])
computer.execute()
assert computer.program[3] == 8
# relative
computer = IntcodeComputer([109, -2, 21101, 5, 7, 4, 99])
computer.execute()
assert computer.relative_base == -2
assert computer.program[2] == 12
def test_take_input():
# position
computer = IntcodeComputer([3, 0, 99], inputs=[1])
computer.execute()
print(computer.program)
assert computer.program[0] == 1
# immediate
computer = IntcodeComputer([103, 5, 99], inputs=[4])
computer.execute()
assert computer.program[1] == 4
# relative to 1, relative input to 1 is memory location 2
computer = IntcodeComputer([9, 1, 203, 1, 99], inputs=[5])
computer.execute()
assert computer.program[2] == 5
def test_2_execute(self):
executor = IntcodeComputer([2, 4, 4, 5, 99, 0])
result = executor.execute()
self.assertListEqual([2, 4, 4, 5, 99, 9801], result)
import utils
from intcode_computer import IntcodeComputer
program = [int(x) for x in utils.read_lines(2)[0].split(",")]
computer = IntcodeComputer()
computer.load_program_from_int_array(program)
# Init to "1202 program alarm" state
computer.set_address(1, 12)
computer.set_address(2, 2)
computer.execute()
print(computer.get_address(0))
computer = IntcodeComputer()
for noun, verb in ((i, j) for i in range(0, 100) for j in range(0, 100)):
print(f"Processing ({noun},{verb})")
computer.load_program_from_int_array(program)
computer.set_address(1, noun)
computer.set_address(2, verb)
computer.execute()
if computer.get_address(0) == 19690720:
print(f"{noun}, {verb} - {100*noun + verb}")
break
def test_1():
intcode_list = list(map(int, open('../5/input.txt').read().split(',')))
computer = IntcodeComputer(intcode_list)
for value in computer.execute(1):
assert value == 0 or value == 4511442
assert value == 4511442
#!/usr/bin/env python3
from intcode_computer import IntcodeComputer
def load_program():
with open("input.txt") as file:
content = file.readlines()
content = [x.strip() for x in content]
program = []
for line in content:
items = line.split(",")
program += [int(item) for item in items]
return program
program = load_program()
executor = IntcodeComputer(program, 12, 2)
terminated_program = executor.execute()
print(terminated_program)
def test_0_execute(self):
executor = IntcodeComputer([1, 0, 0, 0, 99])
result = executor.execute()
self.assertListEqual([2, 0, 0, 0, 99], result)
def test_4_execute(self):
executor = IntcodeComputer([1, 9, 10, 3, 2, 3, 11, 0, 99, 30, 40, 50])
result = executor.execute()
self.assertListEqual([3500, 9, 10, 70, 2, 3, 11, 0, 99, 30, 40, 50], result)
def test_3_execute(self):
executor = IntcodeComputer([1, 1, 1, 4, 99, 5, 6, 0, 99])
result = executor.execute()
self.assertListEqual([30, 1, 1, 4, 2, 5, 6, 0, 99], result)
