def test_opcode_3_makes_read():
input_src = iter([55])
computer = OpcodeComputer([3, 0, 99], input_src=input_src)
computer.run()
assert computer.memory == [55, 0, 99]
def test_read_input_asks_input_generator():
computer = OpcodeComputer([])
computer.input_src = iter([0, 1, 2])
assert computer.read_input() == 0
assert computer.read_input() == 1
assert computer.read_input() == 2
def test_opcode_4_provides_output():
output = Mock()
computer = OpcodeComputer([4, 0, 99], output=output)
computer.run()
output.assert_called_with(4)
def part_a():
"""Part A"""
oc = OpcodeComputer(lines)
# set value at *Position* to `value` with mode being 1 because argument 1 is an address that needs to be
# written to in immediate mode
oc.set_value(1, 12, 1)
oc.set_value(2, 2, 1)
oc.run()
return oc.get_memory()[0]
def test_99_makes_halt_instruction():
computer = OpcodeComputer([99, 1, 2, 3])
factory = InstructionFactory(computer)
instr = factory.load_instruction(0)
assert isinstance(instr, HaltInstruction)
assert instr.computer == computer
def test_2_makes_mult_instruction():
computer = OpcodeComputer([2, 2, 3, 0, 99])
factory = InstructionFactory(computer)
instr = factory.load_instruction(0)
assert isinstance(instr, MultInstruction)
assert instr.params == [Param(2), Param(3), Param(0)]
def part_b():
"""Part B"""
target = 19690720
oc = OpcodeComputer(lines)
for noun in range(0, 100):
for verb in range(0, 100):
# set value at *Position* to `value` with mode being 1 because argument 1 is an address that needs to be
# written to in immediate mode
oc.set_value(1, noun, 1)
oc.set_value(2, verb, 1)
oc.run()
# if target reached
if target == oc.get_memory()[0]:
# return noun and verb (NNVV)
return 100 * noun + verb
# reset memory for another run
oc.reset()
def test_equals_example(input, expected):
computer = OpcodeComputer([3, 3, 1108, -1, 8, 3, 4, 3, 99])
computer.input_src = iter([input])
computer.output = Mock()
computer.run()
computer.output.assert_called_with(expected)
def test_lt_example(input, expected):
computer = OpcodeComputer(
[3, 12, 6, 12, 15, 1, 13, 14, 13, 4, 13, 99, -1, 0, 1, 9])
computer.input_src = iter([input])
computer.output = Mock()
computer.run()
computer.output.assert_called_with(expected)
def __init__(self, program, phase_settings):
self.num_computers = len(phase_settings)
self.input_for_computers = [0] * (self.num_computers + 1)
self.computers = [
OpcodeComputer(list(program)) for _ in range(self.num_computers)
]
def input_getter(n):
yield phase_settings[n]
yield self.input_for_computers[n]
def output_setter(n, val):
self.input_for_computers[n + 1] = val
for i in range(self.num_computers):
self.computers[i].input_src = input_getter(i)
self.computers[i].output = partial(output_setter, i)
def test_large_example(input, expected):
computer = OpcodeComputer([
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
])
computer.input_src = iter([input])
computer.output = Mock()
computer.run()
computer.output.assert_called_with(expected)
def test_immediate_mode_homepage_example():
computer = OpcodeComputer([1002, 4, 3, 4, 33])
computer.run()
assert computer.memory == [1002, 4, 3, 4, 99]
def test_opcode_two_then_halting_multiplies_numbers():
computer = OpcodeComputer([2, 5, 6, 7, 99, 4, 6, 0])
computer.run()
assert computer.memory == [2, 5, 6, 7, 99, 4, 6, 24]
def part_a():
oc = OpcodeComputer(lines, [1])
oc.run()
return oc.get_outputs()[-1:]
def test_adding_two_numbers_in_direct_mode():
computer = OpcodeComputer([1101, 2, 3, 0, 99])
computer.run()
assert computer.memory == [5, 2, 3, 0, 99]
def part_b():
"""Part B"""
oc = OpcodeComputer(lines, [5])
oc.run()
return oc.get_outputs()
def test_stopping_immediately_changes_nothing():
computer = OpcodeComputer([99, 1, 2, 3])
computer.run()
assert computer.memory == [99, 1, 2, 3]
def test_simple_jump():
computer = OpcodeComputer([1106, 0, 6, 104, 1, 99, 104, 2, 99])
computer.output = Mock()
computer.run()
computer.output.assert_called_with(2)
def test_homepage_examples(input, expected):
computer = OpcodeComputer(input)
computer.run()
assert computer.memory == expected
def test_opcode_execute_second_after_first():
computer = OpcodeComputer([1, 0, 0, 0, 2, 0, 0, 0, 99])
computer.run()
assert computer.memory == [4, 0, 0, 0, 2, 0, 0, 0, 99]
from helpers import get_data
from opcode_computer import OpcodeComputer
program = list(map(int, get_data(day=9).split(",")))
computer = OpcodeComputer(program, output=print, input_src=iter([1]))
computer.run()
computer = OpcodeComputer(program, output=print, input_src=iter([2]))
computer.run()
def test_opcode_one_then_halting_adds_numbers():
computer = OpcodeComputer([1, 5, 6, 7, 99, 4, 6, 0])
computer.run()
assert computer.memory == [1, 5, 6, 7, 99, 4, 6, 10]
from opcode_computer import OpcodeComputer
from helpers import get_data
data = get_data(day=5)
program_master = [int(entry) for entry in data.split(',')]
computer = OpcodeComputer(list(program_master),
input_src=iter([1]),
output=print)
computer.run()
# Restart computer, use 5 as input
computer = OpcodeComputer(list(program_master),
input_src=iter([5]),
output=print)
computer.run()
from itertools import product
from opcode_computer import OpcodeComputer
from helpers import get_data
data = get_data(day=2)
program_master = [int(entry) for entry in data.split(',')]
computer = OpcodeComputer(list(program_master))
computer.set_inputs(12, 2)
computer.run()
print(f"Value left at position 0 is {computer[0]}")
for noun, verb in product(range(1, 100), repeat=2):
computer = OpcodeComputer(list(program_master))
computer.set_inputs(noun, verb)
computer.run()
if computer.output == 19690720:
break
print(f"Correct output provided by {noun}, {verb}, with key {100*noun+verb}")
