day17 finished

advent/days/day17/solution.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from itertools import cycle
+
+from typing import Iterator, Self
+
+day_num = 17
+
+
+def part1(lines: Iterator[str]) -> int:
+    cave = Cave.create(7, next(lines))
+    return cave.process_many_rocks(2022)
+
+
+def part2(lines: Iterator[str]) -> int:
+    cave = Cave.create(7, next(lines))
+    return cave.process_many_rocks(1_000_000_000_000)
+
+
+patterns = [["####"],
+            [" # ", "###", " # "],
+            ["###", "  #", "  #"],
+            ["#", "#", "#", "#"],
+            ["##", "##"]
+            ]
+
+
+@dataclass(slots=True, frozen=True)
+class Position:
+    x: int
+    y: int
+
+    def left(self) -> Position:
+        return Position(self.x - 1, self.y)
+
+    def right(self) -> Position:
+        return Position(self.x + 1, self.y)
+
+    def down(self) -> Position:
+        return Position(self.x, self.y - 1)
+
+
+@dataclass(slots=True, frozen=True)
+class Pattern:
+    lines: list[str]
+
+    @property
+    def height(self) -> int:
+        return len(self.lines)
+
+    @property
+    def width(self) -> int:
+        return len(self.lines[0])
+
+    def stones(self, position: Position) -> Iterator[Position]:
+        for y, line in enumerate(self.lines):
+            for x, block in enumerate(line):
+                if block == "#":
+                    yield Position(position.x + x, position.y + y)
+
+
+@dataclass(slots=True)
+class Cave:
+    width: int
+    cave: list[str]
+    gas_pushes: Iterator[str]
+    rock_dispenser: Iterator[Pattern]
+
+    @property
+    def height(self) -> int:
+        return len(self.cave)
+
+    def check_free(self, rock: Pattern, position: Position) -> bool:
+        for block in rock.stones(position):
+            if block.y < len(self.cave) and self.cave[block.y][block.x] == '#':
+                return False
+        return True
+
+    def fix_rock(self, rock: Pattern, position: Position):
+        for _ in range(len(self.cave), position.y + rock.height):
+            self.cave.append(' ' * self.width)
+        for block in rock.stones(position):
+            old = self.cave[block.y]
+            self.cave[block.y] = old[:block.x] + '#' + old[block.x + 1:]
+
+    @ classmethod
+    def create(cls, width: int, gas_pushes: str) -> Self:
+        cave = []
+        return cls(width, cave, cycle(gas_pushes), cycle(Pattern(pattern) for pattern in patterns))
+
+    def process_one_rock(self) -> tuple[Pattern, Position]:
+        rock = next(self.rock_dispenser)
+        position = Position(2, len(self.cave) + 3)
+
+        while True:
+            push = next(self.gas_pushes)
+            if push == '<':
+                if position.x > 0 and self.check_free(rock, position.left()):
+                    position = position.left()
+            else:
+                if (position.x + rock.width < self.width
+                        and self.check_free(rock, position.right())):
+                    position = position.right()
+
+            if position.y > 0 and self.check_free(rock, position.down()):
+                position = position.down()
+            else:
+                self.fix_rock(rock, position)
+                return rock, position
+
+    def process_many_rocks(self, max_rounds: int) -> int:
+        last_landing_row = 0
+        last_max_drop_time = 0
+        last_max_drop_height = 0
+        last_max_drop_row = 0
+        last_max_drop_pattern: Pattern | None = None
+        max_drop_height = 0
+        time = 0
+        added_height = 0
+        while time < max_rounds:
+            pattern, position = self.process_one_rock()
+
+            if position.y < last_landing_row:
+                drop_height = last_landing_row - position.y
+                if drop_height == max_drop_height and last_max_drop_pattern == pattern:
+                    drop_cycle_height = position.y - last_max_drop_row
+                    if last_max_drop_row - drop_cycle_height > 0:
+                        different = False
+                        for row in range(last_max_drop_row - drop_cycle_height, last_max_drop_row):
+                            if self.cave[row] != self.cave[row - drop_cycle_height]:
+                                different = True
+                                break
+                        if not different:
+                            time_diff = time - last_max_drop_time
+                            height_diff = self.height - last_max_drop_height
+                            cycle_count = (max_rounds - time) // time_diff
+                            time += cycle_count * time_diff
+                            added_height = cycle_count * height_diff
+                    last_max_drop_time = time
+                    last_max_drop_height = self.height
+                    last_max_drop_row = position.y
+                elif drop_height > max_drop_height:
+                    last_max_drop_time = time
+                    last_max_drop_height = self.height
+                    last_max_drop_row = position.y
+                    last_max_drop_pattern = pattern
+                    max_drop_height = drop_height
+            last_landing_row = position.y
+            time += 1
+
+        return self.height + added_height