Day 11 - Langton's Ant¶

from __future__ import annotations

from collections import deque
from enum import Enum
from typing import (
    TYPE_CHECKING,
    ContextManager,
    Deque,
    Dict,
    Generator,
    List,
    Literal,
    NamedTuple,
    Optional,
    Tuple,
    Union,
    cast,
)

from intcode import CPU, Instruction, InstructionSet, base_opcodes

TURN = Literal[0, 1]
COLOUR = Literal[0, 1]


class Pos(NamedTuple):
    x: int = 0
    y: int = 0

    def move(self, dx: int, dy: int) -> Pos:
        return self._replace(x=self.x + dx, y=self.y + dy)


Hullmap = Dict[Pos, COLOUR]


class Direction(Enum):
    #       dx, dy, turn l,  turn r
    up = 0, -1, "left", "right"
    left = -1, 0, "down", "up"
    down = 0, 1, "right", "left"
    right = 1, 0, "up", "down"

    if TYPE_CHECKING:
        dx: int
        dy: int
        _turns: Tuple[str, str]

    def __new__(cls, dx: int, dy: int, turn_left: str, turn_right: str) -> Direction:
        self = object.__new__(cls)
        self._value_ = (dx, dy)
        self.dx, self.dy = dx, dy
        self._turns = (turn_left, turn_right)
        return self

    def turn(self, direction: TURN) -> Direction:
        return type(self)[self._turns[direction]]

    def __call__(self, pos: Pos) -> Pos:
        """Move forward one step"""
        return pos.move(self.dx, self.dy)


PaintRunner = Generator[None, Union[TURN, COLOUR], None]


class HullPaintingRobot(ContextManager[PaintRunner]):
    painted: Hullmap
    _runner: Optional[PaintRunner] = None

    def __init__(self, output: Deque[COLOUR]) -> None:
        self.painted = {}
        self._output = output

    def powerdown(self) -> None:
        if self._runner is not None:
            self._runner.close()
            self._runner = None

    def __enter__(self) -> PaintRunner:
        if self._runner is None:
            self._runner = self.run()
            # prime the runner, outputting its first observation
            # and waiting for input.
            next(self._runner)
        return self._runner

    def __exit__(self, *exc) -> None:
        self.powerdown()

    def run(self) -> Generator[None, Union[TURN, COLOUR], None]:
        pos: Pos = Pos()
        direction: Direction = Direction.up
        hull = self.painted

        while True:
            self._output.append(hull.get(pos, 0))
            self.painted[pos] = yield None
            direction = direction.turn((yield None))
            pos = direction(pos)


def testrun() -> None:
    output: Deque[COLOUR] = deque()
    robot = HullPaintingRobot(output)
    with robot as run:
        # and so any input instructions at this point should be provided 0
        assert output[0] == 0

        # Suppose the robot eventually outputs 1 (paint white) and then 0 (turn left)
        run.send(cast(COLOUR, 1))
        run.send(cast(TURN, 0))
        assert robot.painted == {Pos(0, 0): 1}
        # Input instructions should still be provided 0
        assert output[-1] == 0
        assert len(output) == 2

        # Next, the robot might output 0 (paint black) and then 0 (turn left):
        run.send(cast(COLOUR, 0))
        run.send(cast(TURN, 0))
        assert robot.painted == {Pos(0, 0): 1, Pos(-1, 0): 0}

        # After more outputs (1,0, 1,0):
        for c, t in ((1, 0), (1, 0)):
            run.send(cast(COLOUR, c))
            run.send(cast(TURN, t))
        assert robot.painted == {
            Pos(0, 0): 1,
            Pos(-1, 0): 0,
            Pos(-1, 1): 1,
            Pos(0, 1): 1,
        }
        # ... because it is now on a white panel, input instructions should be provided 1
        assert output[-1] == 1

        # After several more outputs (0,1, 1,0, 1,0)
        for c, t in ((0, 1), (1, 0), (1, 0)):
            run.send(cast(COLOUR, c))
            run.send(cast(TURN, t))
        assert robot.painted == {
            Pos(0, 0): 0,
            Pos(-1, 0): 0,
            Pos(-1, 1): 1,
            Pos(0, 1): 1,
            Pos(1, 0): 1,
            Pos(1, -1): 1,
        }


testrun()


def execute_robot(memory: List[int], hull: Optional[Hullmap] = None) -> Hullmap:
    outputs: Deque[COLOUR] = deque()
    robot = HullPaintingRobot(outputs)
    if hull is not None:
        robot.painted = hull
    with robot as runner:
        opcodes: InstructionSet = {
            **base_opcodes,
            3: Instruction(outputs.popleft, output=True),
            4: Instruction(runner.send, 1),
        }
        CPU(opcodes).reset(memory).execute()
    return robot.painted

import aocd

data = aocd.get_data(day=11, year=2019)
memory = list(map(int, data.split(",")))