Solve 2022 day 10

puzzles/solutions/2022/d10/cpu.py

@@ -0,0 +1,70 @@
+from typing import Sequence
+
+
+class CPU:
+    """The handheld device's CPU."""
+
+    _INITIAL_INTERESTING_CYCLE = 20
+    _INTERESTING_CYCLES_DIFFERENCE = 40
+
+    def __init__(self):
+        """Instantiate a CPU."""
+        self._x_register = 1
+
+        self._cycle = 0
+        self._cycle_in_instruction = 0
+        self.is_ready_for_next = False
+
+        self._interesting_cycle = self._INITIAL_INTERESTING_CYCLE
+        self.interesting_signal_strengths_sum = 0
+
+    @property
+    def cycle(self) -> int:
+        """
+        :return: the current CPU's cycle
+        """
+        return self._cycle
+
+    @property
+    def x_register(self) -> int:
+        """
+        :return: the current value of the CPU's x register
+        """
+        return self._x_register
+
+    def run(self, opcode: str, parameters: Sequence[int]) -> None:
+        """
+        Run the given instruction.
+
+        This method also calculates the signal strength at interesting cycles.
+        :param opcode: instruction opcode
+        :param parameters: instruction parameters
+        """
+        self._cycle += 1
+        if self.cycle == self._interesting_cycle:
+            signal_strength = self.cycle * self.x_register
+            self.interesting_signal_strengths_sum += signal_strength
+            self._interesting_cycle += self._INTERESTING_CYCLES_DIFFERENCE
+
+        handler = self._INSTRUCTION_TO_HANDLER[opcode]
+        handler(self, parameters)
+
+    def _finish_instruction(self) -> None:
+        """Set the cycle in instruction counter to zero and mark the CPU as ready for the next instruction."""
+        self._cycle_in_instruction = 0
+        self.is_ready_for_next = True
+
+    def _noop(self, parameters: Sequence[int]) -> None:
+        """Handle `noop` instruction."""
+        self._finish_instruction()
+
+    def _addx(self, parameters: Sequence[int]) -> None:
+        """Handle `addx` instruction."""
+        if self._cycle_in_instruction == 0:
+            self._cycle_in_instruction += 1
+            self.is_ready_for_next = False
+            return
+        self._x_register += parameters[0]
+        self._finish_instruction()
+
+    _INSTRUCTION_TO_HANDLER = {"noop": _noop, "addx": _addx}

puzzles/solutions/2022/d10/handheld_device.py

@@ -0,0 +1,52 @@
+from typing import Sequence
+
+from cpu import CPU
+
+
+class HandheldDevice:
+    """The handheld device, which has a CPU and a CRT screen."""
+
+    _SCREEN_WIDTH = 40
+    _SCREEN_HEIGHT = 6
+
+    _DARK_PIXEL = "."
+    _LIT_PIXEL = "#"
+
+    def __init__(self):
+        """Instantiate a handheld device."""
+        self._cpu = CPU()
+        self._screen = [
+            [self._DARK_PIXEL] * self._SCREEN_WIDTH for _ in range(self._SCREEN_HEIGHT)
+        ]
+
+    def run(self, opcode: str, parameters: Sequence[int]) -> None:
+        """
+        Run the given instruction.
+        :param opcode: instruction opcode
+        :param parameters: instruction parameters
+        """
+        self._cpu.run(opcode, parameters)
+
+    @property
+    def is_ready_for_next(self) -> bool:
+        return self._cpu.is_ready_for_next
+
+    def draw_current_pixel_if_needed(self) -> None:
+        """Draw the pixel under the sprite if the CRT is under it."""
+        current_pixel_row, current_pixel_column = divmod(
+            self._cpu.cycle, self._SCREEN_WIDTH
+        )
+        current_x_register = self._cpu.x_register
+        sprite_boundaries = (
+            current_x_register - 1,
+            current_x_register,
+            current_x_register + 1,
+        )
+        if current_pixel_column in sprite_boundaries:
+            self._screen[current_pixel_row][current_pixel_column] = self._LIT_PIXEL
+
+    def render_screen(self) -> str:
+        """
+        :return: rendered and prettified version of the screen
+        """
+        return "\n".join("".join(row) for row in self._screen)

puzzles/solutions/2022/d10/p1.py

@@ -0,0 +1,38 @@
+import sys
+from typing import Iterator
+
+from cpu import CPU
+
+
+def get_instructions(input_text: str) -> Iterator[tuple[str, tuple[int, ...]]]:
+    """
+    :param input_text: puzzle input
+    :return: generator of instructions and their parameters
+    """
+    for line in input_text.splitlines():
+        instruction, *parameters = line.split()
+        yield instruction, tuple(map(int, parameters))
+
+
+def get_answer(input_text: str):
+    """Return the sum of signal strengths during the 20th, 60th, 100th, 140th, 180th, and 220th cycles of the CPU."""
+    cpu = CPU()
+    instructions = get_instructions(input_text)
+    instruction = next(instructions)
+    while True:
+        instruction_opcode, parameters = instruction
+        cpu.run(instruction_opcode, parameters)
+        if cpu.is_ready_for_next:
+            try:
+                instruction = next(instructions)
+            except StopIteration:
+                break
+
+    return cpu.interesting_signal_strengths_sum
+
+
+if __name__ == "__main__":
+    try:
+        print(get_answer(sys.argv[1]))
+    except IndexError:
+        pass  # Don't crash if no input was passed through command line arguments.

puzzles/solutions/2022/d10/p2.py

@@ -0,0 +1,29 @@
+import sys
+
+from handheld_device import HandheldDevice
+import p1
+
+
+def get_answer(input_text: str):
+    """Return the image drawn on the device's screen after the program is run."""
+    device = HandheldDevice()
+    instructions = p1.get_instructions(input_text)
+    instruction = next(instructions)
+    while True:
+        device.draw_current_pixel_if_needed()
+        instruction_opcode, parameters = instruction
+        device.run(instruction_opcode, parameters)
+        if device.is_ready_for_next:
+            try:
+                instruction = next(instructions)
+            except StopIteration:
+                break
+
+    return device.render_screen()
+
+
+if __name__ == "__main__":
+    try:
+        print(get_answer(sys.argv[1]))
+    except IndexError:
+        pass  # Don't crash if no input was passed through command line arguments.