noop
addx 3
addx -5


# Python imports
from __future__ import annotations

import numpy as np

from pathlib import Path


test = Path("data/day10_test.txt")  # test data
test2 = Path("data/day10_test2.txt")  # more test data
data = Path("data/day10_data.txt")  # puzzle data


class CPU:
    
    """Represents the CPU of the elves' comunicator"""
    
    def __init__(self, display: CRT=None) -> None:
        """Instantiate CPU for elves' communicator
        
        :param display:  CRT object for callback/display
        """
        self.display = display  # holds output display (for callback)
        
        self.regx = 1  # register for X position
        self.cycle_count = 0  # current clock cycle in CPU
        
        self.addx_buffer = []  # two-cycle buffer for addX operation
        self.states = []  # list of (cycle, X) states
        
        # Distribution dictionary for instruction operations
        self.instrs = {"noop": self.noop,
                       "addx": self.addx}
        
    def cycle(self) -> None:
        """Run the CPU for a clock cycle"""
        self.cycle_count += 1  # increment the cell cycle count
        self.states.append((self.cycle_count, self.X))  # store value of X _during_ cycle
        
        # If there's a display, update it with the X value during the cycle
        if self.display is not None:
            self.display.update(self.cycle_count, self.X)
        
        # If the addX buffer is not empty, pop the next value off it
        if len(self.addx_buffer):
            self.regx += self.addx_buffer.pop(0)
        
    def addx(self, val: int) -> None:
        """addX operation
        
        :param val:  the X to be added
        
        To ensure that two cycles are occupied, we use a buffer that
        is popped from the left at each cycle, and add two values:
        0 first, then val.
        """
        self.addx_buffer.append(0)
        self.addx_buffer.append(val)
        
    def noop(self) -> None:
        """noop"""
        pass
        
    def exec_instr(self, instr: list[str] | list[str, int]):
        """Execute a single instruction
        
        :param instr:  the instruction
        
        Uses the internal distribution dictionary
        """
        if instr[0] == "noop":  # noop
            self.instrs["noop"]()
        else:  # non-noop instructions
            self.instrs[instr[0]](instr[1])
            
    def load_instructions(self, instructions: list[list[str] | list[str, int]]) -> None:
        """Load instructions into the CPU
        
        :param instructions:  instructions for the CPU
        """
        self.instructions = instructions
        
    def execute(self, cycles: int) -> None:
        """Run CPU for a number of cycles
        
        :param cycles:  the number of cycles to run for
        """
        for cycle in range(cycles):
            if not len(self.addx_buffer):  # wait to execute pending commands
                if len(self.instructions):  # run pending instruction
                    self.exec_instr(self.instructions.pop(0))
            self.cycle()  # cycle CPU
        
    @property
    def X(self) -> int:
        """Return current value in X register"""
        return self.regx
    
    
def parse_input(fpath: Path):
    """Parse puzzle input into
    
    :param fpath: path to puzzle input
    """
    with fpath.open() as ifh:
        instructions = [_.strip().split() for _ in ifh.readlines()]
        for instr in instructions:
            if len(instr) == 2:  # if there are two values, cast second as int
                instr[1] = int(instr[1])
                
    return instructions
    
def part1(fpath: Path, cycles: int) -> int | list[tuple[int, int]]:
    """Solve the puzzle
    
    :param fpath:  path to puzzle input
    :param cycles:  number of cycles to run the CPU
    """
    cpu = CPU()
    cpu.load_instructions(parse_input(fpath))
    cpu.execute(cycles)

    if cycles > 5:  # second test and puzzle
        print(sum([cpu.states[idx][0] * cpu.states[idx][1] for idx in range(19, 220, 40)]))
    else:  # first test data
        return cpu.states


part1(test, 5)

[(1, 1), (2, 1), (3, 1), (4, 4), (5, 4)]


part1(test2, 220)

13140


part1(data, 220)

14240

Cycle   1 -> ######################################## <- Cycle  40
Cycle  41 -> ######################################## <- Cycle  80
Cycle  81 -> ######################################## <- Cycle 120
Cycle 121 -> ######################################## <- Cycle 160
Cycle 161 -> ######################################## <- Cycle 200
Cycle 201 -> ######################################## <- Cycle 240


class CRT:
    
    """Represents the CRT of the elves' communicator"""
    
    def __init__(self) -> None:
        """Instantiate CRT with internal CPU"""
        self.cpu = CPU(self)  # CPU for executing instructions
        
        self.display = np.zeros(240)  # 1D array
        
    def load_instructions(self, instructions: list[list[str] | list[str, int]]) -> None:
        """Load instructions for CRT into CPU
        
        :param instructions:  instructions for CRT
        """
        self.cpu.load_instructions(instructions)
        
    def run(self, cycles: int=240) -> None:
        """Run CPU for a set number of cycles
        
        :param cycles:  number of cycles to run CPU
        """
        self.cpu.execute(cycles)

    def update(self, cycle: int, spritepos: int) -> None:
        """Callback: CPU updates the CRT display at a named cycle
        
        :param cycle:  current CPU cycle
        :param spritepos:  position of sprite during this cycle
        
        Pixel displays at position cycle (mod 40) in the display, if
        the sprite centre (CPU X register value) is one pixel or less
        from that position.
        """
        if abs(spritepos - (cycle - 1) % 40) < 2:
            self.display[cycle-1] = 1
        
    def __str__(self) -> str:
        """Return string representation of CRT display"""
        display = self.display.reshape(6,40)  # reshape array for display
        outstr = []  # hold display image
        for row in display:  # convert each row of the array to string
            curstr = ""
            for elem in row:
                if elem == 0:
                    curstr += "."
                else:
                    curstr += "#"
            outstr.append(curstr)
            
        return "\n".join(outstr)

def part2(fpath: Path):
    """Solve the puzzle
    
    :param fpath:  path to puzzle input
    """
    instructions = parse_input(fpath)
    crt = CRT()
    crt.load_instructions(instructions)
    crt.run()
    print(crt)


part2(test2)

##..##..##..##..##..##..##..##..##..##..
###...###...###...###...###...###...###.
####....####....####....####....####....
#####.....#####.....#####.....#####.....
######......######......######......####
#######.......#######.......#######.....


part2(data)

###..#....#..#.#....#..#.###..####.#..#.
#..#.#....#..#.#....#.#..#..#....#.#..#.
#..#.#....#..#.#....##...###....#..####.
###..#....#..#.#....#.#..#..#..#...#..#.
#....#....#..#.#....#.#..#..#.#....#..#.
#....####..##..####.#..#.###..####.#..#.

Day 10: Cathode-Ray Tube¶

Part 1¶

Part 2¶