Solve 2022 day 05

puzzles/solutions/2022/d05/consts.py

@@ -0,0 +1,5 @@
+INPUT_PARTS_SPLITTER = "\n\n"
+AMOUNT_LINE_NUMBER = -1
+AMOUNT_INDEX_IN_LINE = -2
+FIRST_CRATE_INDEX = 1
+STEP_BETWEEN_CRATES = 4

puzzles/solutions/2022/d05/input_parsing.py

@@ -0,0 +1,52 @@
+import re
+
+import consts
+from stack import Stack
+from step import Step
+
+
+def get_starting_stacks(stacks_input: str) -> tuple[Stack]:
+    """
+    :param stacks_input: stacks part of the puzzle input
+    :return: tuple of `Stack`s parsed from the input
+    """
+    lines = stacks_input.splitlines()
+    stacks_amount = int(lines[consts.AMOUNT_LINE_NUMBER][consts.AMOUNT_INDEX_IN_LINE])
+
+    stacks = tuple(Stack(()) for _ in range(stacks_amount))
+    stacks_lines = reversed(
+        lines[: consts.AMOUNT_LINE_NUMBER]  # Start building stacks from the bottom up.
+    )
+
+    for line in stacks_lines:
+        for index, stack_number in zip(
+            range(
+                consts.FIRST_CRATE_INDEX,
+                consts.FIRST_CRATE_INDEX + consts.STEP_BETWEEN_CRATES * stacks_amount,
+                consts.STEP_BETWEEN_CRATES,
+            ),
+            range(stacks_amount),
+        ):
+            character = line[index]
+            if (
+                character.isalpha()
+            ):  # Crates are represented by letters. The other character is a space,
+                # which means that no crate is in this line on that stack.
+                stacks[stack_number].add_crates(character)
+
+    return stacks
+
+
+def get_procedure_steps(procedure_input: str) -> tuple[Step]:
+    """
+    :param procedure_input: procedure steps part of the puzzle input
+    :return: tuple of `Step`s parsed from the input
+    """
+    steps = []
+    for line in procedure_input.splitlines():
+        values = re.match(
+            r"move (?P<amount>\d+) from (?P<src>\d+) to (?P<dst>\d+)", line
+        ).groupdict()
+        values = {field: int(value) for field, value in values.items()}
+        steps.append(Step(**values))
+    return tuple(steps)

puzzles/solutions/2022/d05/p1.py

@@ -0,0 +1,34 @@
+import sys
+from typing import Sequence
+
+import consts
+import input_parsing
+from stack import Stack
+from step import Step
+
+
+def execute_transfer_step(stacks: Sequence[Stack], step: Step):
+    """
+    Process a transferring of crates between stacks.
+    :param stacks: sequence of `Stack`s
+    :param step: step to execute
+    """
+    crates = stacks[step.src - 1].remove_crates(step.amount)
+    stacks[step.dst - 1].add_crates(crates)
+
+
+def get_answer(input_text: str):
+    """Return the crates that end up on top of each stack after the rearrangement procedure completes."""
+    starting_stacks, steps = input_text.split(consts.INPUT_PARTS_SPLITTER)
+    stacks = input_parsing.get_starting_stacks(starting_stacks)
+    steps = input_parsing.get_procedure_steps(steps)
+    for step in steps:
+        execute_transfer_step(stacks, step)
+    return "".join(stack.top for stack in stacks)
+
+
+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/d05/p2.py

@@ -0,0 +1,39 @@
+import sys
+from typing import Sequence
+
+import consts
+import input_parsing
+from stack import Stack
+from step import Step
+
+
+def execute_transfer_step(stacks: Sequence[Stack], step: Step):
+    """
+    Process a transferring of crates between stacks.
+    :param stacks: sequence of `Stack`s
+    :param step: step to execute
+    """
+    crates = stacks[step.src - 1].remove_crates(step.amount)
+    stacks[step.dst - 1].add_crates(
+        reversed(tuple(crates))
+    )  # Reverse the crates because now they now retain their order when transferred.
+
+
+def get_answer(input_text: str):
+    """
+    Return the crates that end up on top of each stack after the rearrangement procedure completes,
+    now when crates retain their order.
+    """
+    starting_stacks, steps = input_text.split(consts.INPUT_PARTS_SPLITTER)
+    stacks = input_parsing.get_starting_stacks(starting_stacks)
+    steps = input_parsing.get_procedure_steps(steps)
+    for step in steps:
+        execute_transfer_step(stacks, step)
+    return "".join(stack.top for stack in stacks)
+
+
+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/d05/stack.py

@@ -0,0 +1,42 @@
+from typing import Sequence, Iterable
+
+
+class Stack:
+    """Class representing a stack of crates."""
+
+    def __init__(self, initial_crates: Sequence[str]):
+        """
+        Instantiate a stack.
+        :param initial_crates: initial crates in the stack
+        """
+        self._crates = list(initial_crates)
+
+    def __str__(self) -> str:
+        """
+        :return: a string representation of the crates in the stack
+        """
+        return " ".join(self._crates)
+
+    def remove_crates(self, amount: int) -> Iterable[str]:
+        """
+        Remove crates from the top of the stack and return a list of them.
+        :param amount: amount of crates to remove
+        :return: removed crates
+        """
+        removed = self._crates[-amount:]
+        self._crates = self._crates[:-amount]
+        return reversed(removed)
+
+    def add_crates(self, crates: Iterable[str]):
+        """
+        Add crates to the stack.
+        :param crates: crates to add to the stack
+        """
+        self._crates.extend(crates)
+
+    @property
+    def top(self) -> str:
+        """
+        :return: crate at the top of the stack
+        """
+        return self._crates[-1]

puzzles/solutions/2022/d05/step.py

@@ -0,0 +1,10 @@
+import dataclasses
+
+
+@dataclasses.dataclass
+class Step:
+    """A step of moving crates between stacks."""
+
+    amount: int
+    src: int
+    dst: int