def run(noun, verb=0):
computer = Computer.load()
computer[1], computer[2] = noun, verb
computer.run()
return computer[0]
def test(x, y):
computer = Computer.load()
computer.inputs.append(x)
computer.inputs.append(y)
computer.run()
return computer.outputs.popleft()
def network():
computers = list()
last = dict()
x, y = None, None
for i in range(50):
computers.append(Computer.load([i]))
while True:
for i, computer in enumerate(computers):
if computer.inputs:
last[i] = computer.inputs[0]
try:
computer.tick()
except Input:
computer.inputs.append(-1)
if len(computer.outputs) == 3:
destination = computer.outputs.popleft()
x = computer.outputs.popleft()
y = computer.outputs.popleft()
if destination == 255:
yield 255, x, y
else:
computers[destination].inputs.append(x)
computers[destination].inputs.append(y)
if all(v == -1 for v in last.values()):
if x is not None and y is not None:
yield 0, x, y
computers[0].inputs.append(x)
computers[0].inputs.append(y)
def build(grid):
q = deque([[(0, 0), Computer.load().program]])
station = (-1, -1)
while q:
position, program = q.popleft()
output = -1
for delta, command in directions:
move = tuple(map(add, delta, position))
computer = Computer(program.copy())
computer.inputs.append(command)
while not computer.outputs:
computer.tick()
output = computer.outputs.popleft()
if output != 0:
if move not in grid:
q.append([move, computer.program])
if output == 2:
station = move
grid[move] = output
return station
def execute(commands):
computer = Computer.load()
for command in commands.lstrip().split('\n'):
computer.execute(command)
computer.run()
for output in computer.outputs:
if output > 127:
return output
print('Failed ---')
for character in computer.outputs:
print(chr(character), end='')
def find(start, end):
results = []
for permutation in itertools.permutations(range(start, end + 1)):
computers = [Computer.load([phase]) for phase in permutation]
signal = 0
for computer in itertools.cycle(computers):
computer.inputs.append(signal)
try:
while not computer.outputs:
computer.tick()
signal = computer.outputs.popleft()
except Halt:
results.append(signal)
break
return max(results)
def paint(panel=0):
c = Computer.load()
pos = (0, 0)
dirs = ((0, -1), (1, 0), (0, 1), (-1, 0))
direction = 0
panels = defaultdict(int)
panels[(0, 0)] = panel
while not c.halted:
c.inputs.append(panels[pos])
while len(c.outputs) != 2 and not c.halted:
try:
c.tick()
except Halt:
pass
if c.outputs:
panels[pos] = c.outputs.popleft()
direction = (direction + (-1, 1)[c.outputs.popleft()]) % len(dirs)
pos = (pos[0] + dirs[direction][0], pos[1] + dirs[direction][1])
return panels
def run(value):
computer = Computer.load([value])
computer.run()
return computer.outputs.pop()
from operator import add
from collections import deque
from intcode import Computer
computer = Computer.load()
grid = list()
row = list()
intersections = list()
computer.run()
while computer.outputs:
if (char := computer.outputs.popleft()) == 10:
grid.append(row)
row = list()
else:
row.append(chr(char))
for y, row in enumerate(grid):
for x, cell in enumerate(row):
if cell == '#':
for move in ((0, -1), (0, 1), (-1, 0), (1, 0)):
dx, dy = tuple(map(add, move, (x, y)))
if 0 <= dy < len(grid) and 0 <= dx < len(grid[dy]):
if grid[dy][dx] == '.':
break
else:
intersections.append((x, y))
import os
import itertools
import re
from intcode import Computer, Input
def run_until_input(computer):
try:
computer.run()
except Input:
return
items = list()
computer = Computer.load(filename=f'{os.path.dirname(__file__)}/memory.out')
for execute in ('west', 'north', 'west', 'west', 'west'):
computer.execute(execute)
run_until_input(computer)
for line in computer.screen().split('\n'):
if line == 'Items here:':
items = list()
elif line.startswith('- '):
items.append(line[2:])
for i in range(len(items)):
for combination in itertools.combinations(items, i):
for item in combination:
def run(user_id):
computer = Computer.load([user_id])
computer.run()
return computer.outputs.pop()
