def runRobot(instructions):
robotController = getInputData()
IC = IntcodeComputer(robotController)
IC.run_program(instructions)
outCode = IC._output
# print(ascii2str(outCode))
return ascii2str(outCode)
def day05PartOne():
prg = getInputData()
IntCode = IntcodeComputer(prg)
print(
f'Solution Day 05, Part one:\nRunning TEST diagnostic program...\nGive manual input=>1\n'
)
IntCode.run_program()
def day05PartTwo():
prg2 = getInputData()
IntCode2 = IntcodeComputer(prg2)
print(
f'Solution Day 05, Part two:\nRunning TEST diagnostic program...\nGive manual input=>5\n'
)
IntCode2.run_program()
def run_the_magic_program(input_sequence, noun, verb):
# create a copy of input_sequence to make sure we don't change the
# original one
input_sequence_copy = input_sequence.copy()
input_sequence_copy[1] = noun
input_sequence_copy[2] = verb
command_invoker = IntcodeComputer(program=input_sequence_copy)
command_invoker.run_program()
return command_invoker.get_memory_state()[0]
def solution():
from pathlib import Path
input_file = Path(INPUT_FILE)
# parse the sequence of commands and put the value as the computer input
num_sequence = parse_program(input_file)
computer = IntcodeComputer(program=num_sequence)
computer.send_input_data(2)
# set the input value that we want to pass to the Input command
computer.run_program()
return computer.output_buffer.value
def solution():
from pathlib import Path
input_file = Path(INPUT_FILE)
# parse the sequence of commands and replace two elements with values
# according to the task
num_sequence = parse_program(input_file)
computer = IntcodeComputer(program=num_sequence)
# set the input value that we want to pass to the Input command
computer.send_input_data(5)
computer.run_program()
return computer.output_buffer.value
def solution():
from pathlib import Path
input_file = Path(INPUT_FILE)
# parse the sequence of commands and replace two elements with values
# according to the task
program = parse_program(input_file)
program[1] = 12
program[2] = 2
# do the calculation
computer = IntcodeComputer(program=program)
computer.run_program()
result = computer.get_memory_state()
return result[0]
def paint_ship(program, start_colour):
location = (0, 0)
direction = 0
panels = {}
panels[location] = start_colour
computer = IntcodeComputer(program)
program_output = computer.run_program()
while True:
current_panel = panels.setdefault(location)
computer.add_input(0 if current_panel is None else current_panel)
try:
colour = next(program_output)
turn = next(program_output)
except StopIteration:
break
panels[location] = colour
direction = (direction + turn*2 - 1) % 4
location = (location[0] + DIRECTIONS[direction][0],
location[1] + DIRECTIONS[direction][1])
return panels
def isInBeam(x, y):
code = getInputData()
IC = IntcodeComputer(code)
o = IC.run_program([x, y])
if o[0] == 1:
return True
else:
return False
def part_2(input_data, desired_value):
int_comp = IntcodeComputer(input_data)
for i in range(100):
for j in range(100):
input_data[1] = i
input_data[2] = j
output = int_comp.run_program(input_data)
if output != 4023471:
print('debug')
if output == desired_value:
return 100 * i + j
def drone(h=50, w=50):
code = getInputData()
# IC = IntcodeComputer(code)
# out = {}
pic = []
count = 0
for y in range(h):
row = ''
for x in range(w):
IC = IntcodeComputer(code)
o = IC.run_program([x, y])
if o[0] == 1:
count += 1
row += '#'
else:
row += '.'
pic.append(row)
# print(out)
for r in pic:
print(r)
return count
def doTheSpacewalk():
code = getInputData()
IC = IntcodeComputer(code)
IC._intCodeProgramDict[
0] = 2 # orce the vacuum robot to wake up by changing the value in your ASCII program at address 0 from 1 to 2
# print(IC._intCodeProgramDict)
M = 'A,B,A,B,A,C,B,C,A,C\n'
A = 'L,10,L,12,R,6\n'
B = 'R,10,L,4,L,4,L,12\n'
C = 'L,10,R,10,R,6,L,4\n'
F = 'n\n' # continuous video feed; provide either y or n and a newline
Ml = [ord(ch) for ch in M]
Al = [ord(ch) for ch in A]
Bl = [ord(ch) for ch in B]
Cl = [ord(ch) for ch in C]
Fl = [ord(ch) for ch in F]
input = Ml + Al + Bl + Cl + Fl
# print(input)
output = IC.run_program(input)
# print(output)
map = decodeMap(output[:-1])
printMap(map)
return output[
-1] # amount of space dust it collected as a large, non-ASCII value in a single output instruction.
def getReturnValue(settingList, amplifierInputCopy):
print(settingList)
IntComp = IntcodeComputer(amplifierInputCopy)
val = IntComp.run_program(settingList)
return val
def getInputData():
'''Reads the input file end returns the data in a list of int'''
data = []
with open(inputFile) as input:
for line in input:
data = [int(x) for x in line.split(',')]
return data
if __name__ == "__main__":
prg = getInputData()
#print(prg)
IC = IntcodeComputer(prg)
IC.run_program()
str = ""
str = str.join(([chr(ch) for ch in IC._output]))
print(str)
'''
. . *** **
! . ._*. .
- -*- - .-'-. ! ! .
. . * .-' .-. '-.! ! . .
*** .-' .-' '-. '-.! .
* ***.-' .-' '-. '-. .
* ***$*.-' '-. '-. *
* *** * *** ___________ !-..!-. * * * *
* *** **$** * !__!__!__!__! ! ! *** *** . * ***
*** **** * ***** !__!__!__!__! ! .***-.-*** * *** * #_
********** * ****$ * !__!__!__!__! !-..--'***** # '*-..---# ***
puzzle = (2019, 7)
# Initialise the helper library
aoc = AOCLib(puzzle[0])
puzzle_input = aoc.get_puzzle_input(puzzle[1], AOCLib.to_list_int)
highest_signal = 0
for phase in permutations(range(5)):
last_output = 0
for amp in range(5):
computer = IntcodeComputer(puzzle_input, phase[amp], last_output)
last_output = next(computer.run_program())
if last_output > highest_signal:
highest_signal = last_output
aoc.print_solution(1, highest_signal)
max_thruster_signal = -1
for phase in permutations(range(5, 10)):
computers = []
generators = []
for amp in range(5):
computers.append(IntcodeComputer(puzzle_input))
computers[amp].add_input(phase[amp])
generators.append(computers[amp].run_program())
data = 0
def BOOSTkeycode(intOpPrg, input):
IntComp = IntcodeComputer(intOpPrg)
keycode = IntComp.run_program(inp=input)
return keycode
def test_example2(self):
IC = IntcodeComputer([103,7,8,7,8,9,99,-1,8])
IC.run_program([8])
self.assertEqual(IC.readMem(7), -1)
self.assertEqual(IC.readMem(1), 8)
def test_example1(self):
IC = IntcodeComputer([3,7,8,7,8,7,99,-1,8])
IC.run_program([8])
self.assertEqual(IC.readMem(7), 1)
def part_1(input_data):
int_comp = IntcodeComputer(input_data)
input_data[1] = 12
input_data[2] = 2
return int_comp.run_program(input_data)
def runIntCode(self, code, input=[]):
IntCode = IntcodeComputer(code)
output = IntCode.run_program(input)
return output
