def robot(prog, white=set()):
painted = set()
rpos, rdir = [0, 0], [0, -1]
cycle = ['paint'] # or 'turn'
def robot_in():
return 1 if tuple(rpos) in white else 0
def robot_out(n):
if cycle[0] == 'paint':
cycle[0] = 'turn'
p = tuple(rpos)
painted.add(p)
if n == 0: white.discard(p)
elif n == 1: white.add(p)
else: raise RuntimeError(f'bad paint: {n}')
else:
cycle[0] = 'paint'
dx, dy = rdir[0], rdir[1]
if n == 0: dx, dy = dy, -dx
elif n == 1: dx, dy = -dy, dx
else: raise RuntimeError(f'bad turn: {n}')
rpos[0] += dx
rpos[1] += dy
rdir[0] = dx
rdir[1] = dy
intcode.run(prog, stdin=robot_in, stdout=robot_out)
return white, painted
def demo():
out = ['x', 0, 0]
pad_x, ball_x = [0], [0]
score = [0]
def demo_in():
if ball_x[0] < pad_x[0]: return -1
if ball_x[0] > pad_x[0]: return 1
return 0
def demo_out(n):
if out[0] == 'x':
out[0] = 'y'
out[1] = n
elif out[0] == 'y':
out[0] = 't'
out[2] = n
else:
out[0] = 'x'
x, y = out[1:3]
if x == -1 and y == 0:
score[0] = n
else:
if n == 3: pad_x[0] = x
if n == 4: ball_x[0] = x
intcode.run(prog, stdin=demo_in, stdout=demo_out)
return score[0]
def part2():
program = intcode.readProgram("input")
pcopy = program.copy()
output = []
intcode.run(program, [], output)
draw(output)
coords = toCoords(output)
pos = findVacuumRobot(coords)
mm = movement(coords, pos, coords[pos])
mm = list(map(str, mm))
# print(mm)
pred = lambda sl: len(",".join(sl)) <= 20
(names, mappings) = split(mm, pred, 0, [])
# print(names)
# print(mappings)
program = pcopy
program[0] = 2 # activate
inputs = [",".join(names) + "\n"]
for k in sorted(mappings.keys(), key=ord):
inputs.append(",".join(mappings[k]) + "\n")
inputs.append("n\n")
def toAscii(inp): return list(map(ord, splitStr(inp)))
inputs = flatten(list(map(toAscii, inputs)))
print(inputs)
output = []
state = intcode.run(program, inputs, output)
print("done? %s" % (state[0],))
print(output)
def game(scr):
curses.curs_set(0)
out = ['x', 0, 0]
def game_in():
ch = scr.getch()
if ch == curses.KEY_LEFT: return -1
if ch == curses.KEY_RIGHT: return 1
return 0
def game_out(n):
if out[0] == 'x':
out[0] = 'y'
out[1] = n
elif out[0] == 'y':
out[0] = 't'
out[2] = n
else:
out[0] = 'x'
x, y = out[1:3]
if x == -1 and y == 0:
scr.addstr(0, 0, str(n))
else:
scr.addch(y+1, x, tiles[n])
scr.refresh()
intcode.run(prog, stdin=game_in, stdout=game_out)
def scan(program, mx, my):
for x in range(0, mx):
for y in range(0, my):
output = []
inp = [x, y]
intcode.run(program.copy(), inp, output)
yield (x, y, output[0])
def calc_phase_setting(initial_memory: List[int],
sequence: Iterable[int]) -> int:
phase_setting = 0
programs: List[Program] = []
halted = False
while not halted:
for i, program_input in enumerate(sequence):
if len(programs) <= i:
programs.append(Program(initial_memory))
# Run with program_input only first time
_, outputs = run(programs[i],
inputs=[program_input, phase_setting])
else:
# Already added -> has run at least once already
_, outputs = run(programs[i], inputs=[phase_setting])
assert len(outputs) > 0
phase_setting = outputs[-1]
halted = programs[i].memory[programs[i].memory_ptr] == 99
if halted:
programs[i].memory_ptr = 0
return phase_setting
def run(sprog):
out = []
intcode.run(prog,
stdin=[ord(c) for c in '\n'.join(sprog) + '\n'],
stdout=out)
print(''.join(chr(c) for c in out if c < 256))
return out[-1]
def get_final_output(ops, input):
latestOutput = None
state = run(ProgramState(ops), input)
while not state.done:
latestOutput = state.output
# print (latestOutput)
state = run(state, [])
return latestOutput
def main():
global grid
# Prepare intcode computer
intcode.init('inputs/painting.txt')
intcode.run(i=instr_in, o=instr_out)
# How many panels painted at least once?
# print(len(grid))
paintID()
def boost(ops, inp):
outputs = []
state = run(ProgramState(ops), [inp])
while not state.done:
print (state.output)
outputs.append(state.output)
state = run(state, [])
print (state.memory)
return outputs
def day2(input_path):
with open(input_path) as f:
rom = np.ascontiguousarray(list(map(int, f.read().split(","))))
ram = rom.copy()
ram[1] = 12
ram[2] = 2
intcode.run(ram, 0)
assert ram[0] == 5290681
assert search(rom) == 5741
def search(rom):
for noun in range(100):
for verb in range(100):
ram = rom.copy()
ram[1] = noun
ram[2] = verb
intcode.run(ram, 0)
if ram[0] == 19690720:
return noun * 100 + verb
raise RuntimeError("Not found")
def execute(code):
program = [[ord(c) for c in line + "\n"] for line in code.split("\n")]
i = []
m = list(data)
o = []
# Test run once
p, r = run(i, m, o)
for i in program:
p, r = run(i, m, o, p, r)
#print(''.join(chr(x) for x in o if x < 256))
return o[-1]
def test_run_example():
mem, ip, inputs, outputs = run([3, 0, 4, 0, 99], inputs=[42])
assert mem == [42, 0, 4, 0, 99]
assert ip == 4
assert not inputs
assert outputs == [42]
memory = [1002, 4, 3, 4, 33]
assert run(memory) == ([1002, 4, 3, 4, 99], 4, [], [])
memory = [1101, 100, -1, 4, 0]
assert run(memory) == ([1101, 100, -1, 4, 99], 4, [], [])
def part1():
program = intcode.readProgram("input")
output = []
intcode.run(program, [], output)
coords = toCoords(output)
intersectionPoints = filter(lambda p:isIntersection(coords, p), coords.keys())
#width = output.index(10)
#for p in intersectionPoints:
# (x, y) = p
# idx = (width+1)*y + x
# output[idx] = ord("O")
#draw(output)
return sum(map(lambda p: p[0]*p[1], intersectionPoints))
def build_graph(program):
dists = {}
graph = defaultdict(list)
inps = []
prog = intcode.run(program, inps)
oxpos = None
def move(cmd):
inps.append(cmd)
return next(prog)
def dfs(pos, dist):
nonlocal oxpos
dists[pos] = dist
for cmd, delta in d.items():
npos = (pos[0] + delta[0], pos[1] + delta[1])
curdist = dists.get(npos, math.inf)
if dist >= curdist:
continue
status = move(cmd)
if status == 2:
oxpos = npos
if status == 1 or status == 2:
graph[pos].append(npos)
graph[npos].append(pos)
dfs(npos, dist + 1)
move(reverse[cmd])
dfs((0, 0), 0)
return graph, oxpos, dists[oxpos]
def run_prog(prog, inp=[]):
outs = []
for mem, out, pc, running in ic.run(prog, iter(inp)):
if not running:
return outs
if out is not None:
outs.append(out)
def part2(program, seq):
program[0] = 2
seqs = simplify(seq)
distinct = list(set(seqs))
main = ','.join(chr(ord('A') + distinct.index(x)) for x in seqs)
lines = [main] + distinct + ['n\n']
return list(intcode.run(program, '\n'.join(lines)))[-1]
def a():
out = defaultdict(int)
for x, y, tile in u.chunks(intcode.run(data, []), 3):
out[(x, y)] = tile
# print_tiles(out)
blocks = len([v for v in out.values() if v == 2])
return blocks
def test_jumps():
memory = [3, 12, 6, 12, 15, 1, 13, 14, 13, 4, 13, 99, -1, 0, 1, 9]
_, _, _, outputs = run(memory, inputs=[0])
assert outputs == [0]
memory = [3, 3, 1105, -1, 9, 1101, 0, 0, 12, 4, 12, 99, 1]
_, _, _, outputs = run(memory, inputs=[0])
assert outputs == [0]
memory = [3, 12, 6, 12, 15, 1, 13, 14, 13, 4, 13, 99, -1, 0, 1, 9]
_, _, _, outputs = run(memory, inputs=[123])
assert outputs == [1]
memory = [3, 3, 1105, -1, 9, 1101, 0, 0, 12, 4, 12, 99, 1]
_, _, _, outputs = run(memory, inputs=[123])
assert outputs == [1]
def first():
state = read_state()
state[1] = 12
state[2] = 2
result = intcode.run(state)
print(result)
def __init__(self, program):
self.field, self.pos, self.dir = set(), None, None
for y, line in enumerate(''.join(map(chr,
intcode.run(program,
()))).split('\n')):
for x, char in enumerate(line):
if char == '#':
self.field.add((x, y))
elif char == '<':
self.pos = x, y
self.dir = -1, 0
elif char == '>':
self.pos = x, y
self.dir = 1, 0
elif char == '^':
self.pos = x, y
self.dir = 0, -1
elif char == 'v':
self.pos = x, y
self.dir = 0, 1
self.crossings = {
(x, y)
for x, y in self.field
if sum(((x - 1, y) in self.field, (x, y - 1) in self.field,
(x, y + 1) in self.field, (x + 1, y) in self.field)) > 2
}
def test_opcode7():
memory = [3, 9, 7, 9, 10, 9, 4, 9, 99, -1, 8]
_, _, _, outputs = run(memory, inputs=[8])
assert outputs == [0]
memory = [3, 3, 1107, -1, 8, 3, 4, 3, 99]
_, _, _, outputs = run(memory, inputs=[8])
assert outputs == [0]
memory = [3, 9, 7, 9, 10, 9, 4, 9, 99, -1, 8]
_, _, _, outputs = run(memory, inputs=[4])
assert outputs == [1]
memory = [3, 3, 1107, -1, 8, 3, 4, 3, 99]
_, _, _, outputs = run(memory, inputs=[4])
assert outputs == [1]
def main():
inputHandle = loadFile("02/input.txt")
opList = fileToList(inputHandle, ",")
for noun, verb in product(range(0, 100), range(0, 100)):
if run(noun, verb, opList) == 19690720:
print( (100 * noun) + verb)
break
def runOnce(self):
inputs = self.queue
if len(inputs) == 0:
inputs = [-1]
self.queue = []
output = []
self.state = intcode.run(self.program, inputs, output, self.state)
self.network.send(output)
def run_tests():
test_i = 0
for tape, input, expected in tests:
result = intcode.run(tape.copy(), input.copy())
if result[1] != expected:
print(test_i, 'failed')
print('got', result[1])
print('instead of', expected)
test_i += 1
def evaluate(noun, verb):
mem = defaultdict(int, enumerate([int(v) for v in data.split(",")]))
mem[1] = noun
mem[2] = verb
for _ in intcode.run(mem, []):
pass
return mem[0]
def part2(lines):
program = [int(s.strip()) for s in lines[0].split(',')]
scaffold = Scaffold(program[:])
input = '\n'.join(
next(result for path in scaffold.paths() for result in compress(path)))
program[0] = 2
for x in intcode.run(program, [ord(c) for c in f'{input}\nn\n']):
if x > 255:
return x
def scan(x, y):
if x < 0 or y < 0:
return 0
i = [x, y]
m = list(data)
o = []
# Test run once
p, r = run(i, m, o)
return o[0]
def part2(program: list):
inputs = itertools.product(range(100), range(100))
for n, v in inputs:
memory = program.copy()
memory[1] = n
memory[2] = v
memory, _, _, _ = run(memory)
if memory[0] == 19690720:
break
return n * 100 + v
