Solve 2022 day 11

puzzles/solutions/2022/d11/keep_away.py

@@ -0,0 +1,63 @@
+from typing import Callable, Iterable
+
+from monkey import Monkey
+
+
+class KeepAway:
+    """Class managing the monkeys' Keep Away game."""
+
+    def __init__(
+        self,
+        monkeys: list[Monkey],
+        rounds_amount: int,
+        worry_level_modifier: Callable[[int, Iterable[Monkey]], int],
+    ):
+        self._monkeys = monkeys
+        self._rounds_amount = rounds_amount
+        self._worry_level_modifier = worry_level_modifier
+
+    def _handle_item(self, item: int, monkey: Monkey) -> None:
+        """
+        Handle a single item -- calculate its worry level and determine the monkey to which the item will be thrown.
+        :param item: item to handle
+        :param monkey: monkey who plays the current turn
+        """
+        worry_level = item
+        worry_level = monkey.worry_function(worry_level)
+        worry_level = self._worry_level_modifier(worry_level, self._monkeys)
+        monkey_number_to_throw_item_to = (
+            monkey.true_test_result_monkey_number
+            if worry_level % monkey.test_divisor == 0
+            else monkey.false_test_result_monkey_number
+        )
+        monkey.throw(self._monkeys[monkey_number_to_throw_item_to], worry_level)
+
+    def _run_turn(self, monkey: Monkey) -> None:
+        """
+        Run a turn.
+        :param monkey: monkey who plays the current turn
+        """
+        items = monkey.items[:]
+        for item in items:
+            self._handle_item(item, monkey)
+        monkey.empty_items()
+
+    def run(self) -> None:
+        """Run the Keep Away game."""
+        for _ in range(self._rounds_amount):
+            for monkey in self._monkeys:
+                self._run_turn(monkey)
+
+    def get_monkey_business_level(self) -> int:
+        """
+        :return: monkey business level, which is the product of the inspected items amount of the two most active
+        monkeys in the game.
+        """
+        two_most_active_monkeys = sorted(
+            self._monkeys, key=lambda monkey: monkey.inspected_items_amount
+        )[-2:]
+        monkey_business = (
+            two_most_active_monkeys[0].inspected_items_amount
+            * two_most_active_monkeys[1].inspected_items_amount
+        )
+        return monkey_business

puzzles/solutions/2022/d11/monkey.py

@@ -0,0 +1,33 @@
+import dataclasses
+from typing import Callable, Self
+
+
+@dataclasses.dataclass
+class Monkey:
+    """Class representing a monkey playing Keep Away."""
+
+    items: list[int]
+    worry_function: Callable[[int], int]
+    test_divisor: int
+    true_test_result_monkey_number: int
+    false_test_result_monkey_number: int
+    inspected_items_amount: int = 0
+
+    def throw(self, other: Self, item_to_throw: int) -> None:
+        """
+        Throw the given item to another monkey.
+
+        This method also increments the items inspected amount (every inspected item is eventually thrown).
+        :param other: other monkey to throw item to
+        :param item_to_throw: item to throw
+        """
+        other.items.append(item_to_throw)
+        self.inspected_items_amount += 1
+
+    def empty_items(self) -> None:
+        """
+        Empty the items list of the monkey.
+
+        Use when the monkey's turn ends (monkeys have no items at the end of the round).
+        """
+        self.items = []

puzzles/solutions/2022/d11/monkey_creator.py

@@ -0,0 +1,68 @@
+from typing import Sequence, Callable
+import re
+import operator
+
+from monkey import Monkey
+
+
+_FIRST_PARAMETER = "first_parameter"
+_OPERATOR = "operator"
+_SECOND_PARAMETER = "second_parameter"
+_OLD = "old"
+PLUS_SIGN = "+"
+
+
+def create_monkey(monkey_attributes: Sequence[str]) -> Monkey:
+    """
+    :param monkey_attributes: list of lines containing the monkey attributes
+    :return: monkey created from the attributes
+    """
+    starting_items_match = re.findall(r"\b\d+\b", monkey_attributes[0])
+    starting_items = list(int(item) for item in starting_items_match)
+
+    worry_function = _get_worry_function(monkey_attributes[1])
+
+    test_divisor_match = re.search(r"\d+", monkey_attributes[2])
+    test_divisor = int(test_divisor_match.group())
+
+    true_test_result_monkey_number_match = re.search(r"\d+", monkey_attributes[3])
+    true_test_result_monkey_number = int(true_test_result_monkey_number_match.group())
+
+    false_test_result_monkey_number_match = re.search(r"\d+", monkey_attributes[4])
+    false_test_result_monkey_number = int(false_test_result_monkey_number_match.group())
+
+    return Monkey(
+        starting_items,
+        worry_function,
+        test_divisor,
+        true_test_result_monkey_number,
+        false_test_result_monkey_number,
+    )
+
+
+def _get_worry_function(
+    line: str,
+) -> Callable[[int], int]:
+    """
+    :param line: line from the input containing the worry level function
+    :return: function calculating the new worry level based on the old level
+    """
+    parameters = re.search(
+        rf"(?P<{_FIRST_PARAMETER}>\d+|{_OLD}) (?P<{_OPERATOR}>[*+]) (?P<{_SECOND_PARAMETER}>\d+|{_OLD})",
+        line,
+    ).groupdict()
+
+    first_parameter = parameters[_FIRST_PARAMETER]
+    operator_function = (
+        operator.add if parameters[_OPERATOR] == PLUS_SIGN else operator.mul
+    )
+    second_parameter = parameters[_SECOND_PARAMETER]
+
+    if first_parameter == _OLD:
+        if second_parameter == _OLD:
+            return lambda old: operator_function(old, old)
+        second_parameter = int(second_parameter)
+        return lambda old: operator_function(old, second_parameter)
+    first_parameter = int(first_parameter)
+    if second_parameter == _OLD:
+        return lambda old: operator_function(first_parameter, old)

puzzles/solutions/2022/d11/p1.py

@@ -0,0 +1,42 @@
+import sys
+from typing import Iterable
+
+from monkey import Monkey
+from monkey_creator import create_monkey
+from keep_away import KeepAway
+
+
+RELIEF_WORRY_REDUCTION_FACTOR = 3
+ROUNDS_AMOUNT = 20
+
+
+def create_monkeys(input_text: str) -> list[Monkey]:
+    """
+    :param input_text: puzzle input
+    :return: list of monkeys
+    """
+    monkeys = []
+    for monkey_attributes in input_text.split("\n\n"):
+        monkey_attributes = tuple(map(str.strip, monkey_attributes.splitlines()))
+        monkey = create_monkey(monkey_attributes[1:])
+        monkeys.append(monkey)
+    return monkeys
+
+
+def modify_worry_level(worry_level: int, monkeys: Iterable[Monkey]) -> int:
+    return worry_level // RELIEF_WORRY_REDUCTION_FACTOR
+
+
+def get_answer(input_text: str):
+    """Get the monkey business level at the end of the Keep Away game."""
+    monkeys = create_monkeys(input_text)
+    game = KeepAway(monkeys, ROUNDS_AMOUNT, modify_worry_level)
+    game.run()
+    return game.get_monkey_business_level()
+
+
+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/d11/p2.py

@@ -0,0 +1,38 @@
+import sys
+from pathlib import Path
+from typing import Iterable
+
+import p1
+from keep_away import KeepAway
+from monkey import Monkey
+
+
+SOLUTIONS_DIRECTORY = str(Path(__file__).resolve().parents[2])
+sys.path.insert(0, SOLUTIONS_DIRECTORY)
+from utils import crt
+
+
+ROUNDS_AMOUNT = 10_000
+
+
+def modify_worry_level(worry_level: int, monkeys: Iterable[Monkey]) -> int:
+    moduli_to_remainders = {
+        current_monkey.test_divisor: worry_level % current_monkey.test_divisor
+        for current_monkey in monkeys
+    }
+    return crt.calculate_chinese_remainder_theorem(moduli_to_remainders)
+
+
+def get_answer(input_text: str):
+    """Get the monkey business level at the end of the Keep Away game."""
+    monkeys = p1.create_monkeys(input_text)
+    game = KeepAway(monkeys, ROUNDS_AMOUNT, modify_worry_level)
+    game.run()
+    return game.get_monkey_business_level()
+
+
+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.