Everybody Codes: tidy 2025/14

Author: IsaacG

everybody_codes/event2025/quest_14.py

@@ -1,118 +1,77 @@
 """Everyone Codes Day N."""
 
-import logging
 from lib import helpers
 from lib import parsers
 
-log = logging.info
-DIAGS = [1+1j, 1-1j,-1+1j,-1-1j]
+DIAGONALS = [(x, y) for x in [-1, 1] for y in [-1, 1]]
 
-def p3(data):
-    all_coords = [complex(x, y) for x in range(34) for y in range(34)]
-    active = set()
 
-    def neighbors(i):
-        for d in DIAGS:
-            if i + d in all_coords:
-                yield i + d
-
-    def print_active():
-        for y in range(34):
-            print("".join(
-                "#" if complex(x,y) in active else "."
-                for x in range(34)
-            ))
-
-    want_steps = 1000000000
-    assert data.max_x == data.max_y == 7
-    want_active = {i + 13 + 13j for i in data.all_coords if i in data.coords["#"]}
-    want_off = {i + 13 + 13j for i in data.all_coords if i not in data.coords["#"]}
-    # print(f"{len(want_active)=}")
-    # print(f"{len(want_off)=}")
-
-    if False:
-        for y in range(13, 13+9):
-            print("".join(
-                "#" if complex(x,y) in want_active else "."
-                for x in range(13, 13+9)
-            ))
-        print()
-
-        for y in range(13, 13+9):
-            print("".join(
-                "#" if complex(x,y) in want_off else "."
-                for x in range(13, 13+9)
-            ))
-        print()
+def solve(part: int, data: str) -> int:
+    """Solve the parts."""
+    lines = data.splitlines()
+    input_width = len(lines[0])
+    input_height = len(lines)
+    assert input_width == input_height
+    board_size = input_width if part in [1, 2] else 34
+
+    offset = 0 if part in [1, 2] else (board_size - input_width) // 2
+    input_active = {
+        (x + offset, y + offset)
+        for y, line in enumerate(lines)
+        for x, char in enumerate(line)
+        if char == "#"
+    }
+    # Used for part 3.
+    input_inactive = {
+        (x + offset, y + offset)
+        for y, line in enumerate(lines)
+        for x, char in enumerate(line)
+        if char != "#"
+    }
+
+    active = frozenset() if part == 3 else frozenset(input_active)
+
+    def neighbors(x, y):
+        return [(x + dx, y + dy) for dx, dy in DIAGONALS if 0 <= x + dx < board_size and 0 <= y + dy < board_size]
+
+    want_steps = [10, 2025, 1000000000][part - 1]
 
     total = 0
     seen_at = {}
-    seen = {}
+    seen: dict[frozenset[tuple[int, int]], int] = {}
 
     for step in range(5000):
         active = frozenset({
-            c for c in all_coords
+            (x, y) for x in range(board_size) for y in range(board_size)
             if (
-                (c in active and sum(n in active for n in neighbors(c)) % 2 == 1)
-                or (c not in active and sum(n in active for n in neighbors(c)) % 2 == 0)
+                ((x, y) in active and sum(n in active for n in neighbors(x, y)) % 2 == 1)
+                or ((x, y) not in active and sum(n in active for n in neighbors(x, y)) % 2 == 0)
             )
         })
-        if want_active.issubset(active) and want_off.isdisjoint(active):
-            print(step)
+
+        if part != 3:
+            total += len(active)
+            if step + 1 == want_steps:
+                return total
+        elif input_active.issubset(active) and input_inactive.isdisjoint(active):
             seen_at[step] = len(active)
             if active in seen:
                 cycle_start = seen[active]
                 cycle = step - cycle_start
-                print(f"{seen_at=}")
-                print(f"{cycle_start=}")
-                print(f"{cycle=}")
-                spots = set()
+                spots: set[int] = set()
                 for prior in seen_at:
                     if prior >= cycle_start:
-                        spots.update(range(cycle_start+(prior-cycle_start), want_steps, cycle))
-                total = 0
-                for spot in spots:
-                    total += seen_at[((spot - cycle_start) % cycle) + cycle_start]
-                return total
+                        spots.update(range(cycle_start + (prior - cycle_start), want_steps, cycle))
+                return sum(
+                    seen_at[((spot - cycle_start) % cycle) + cycle_start]
+                    for spot in spots
+                )
 
             seen[active] = step
-    raise RuntimeError("Nope")
-
-def solve(part: int, data: str) -> int:
-    """Solve the parts."""
-    if part == 3:
-        return p3(data)
-    active = data.coords["#"]
-    total = 0
-
-    def neighbors(i):
-        for d in DIAGS:
-            if i + d in data.all_coords:
-                yield i + d
-
-    def print_active():
-        for y in range(data.max_y+1):
-            print("".join(
-                "#" if complex(x,y) in active else "."
-                for x in range(data.max_x+1)
-            ))
-
-    for _ in range(10 if part == 1 else 2025):
-        #print_active()
-        #print()
-        active = {
-            c for c in data.all_coords
-            if (
-                (c in active and sum(n in active for n in neighbors(c)) % 2 == 1)
-                or (c not in active and sum(n in active for n in neighbors(c)) % 2 == 0)
-            )
-        }
-        # print( len(active))
-        total += len(active)
-    return total
+    raise RuntimeError("No solution found.")
 
 
-PARSER = parsers.CoordinatesParser()
+PARSER = parsers.parse_one_str
 TEST_DATA = [
     """\
 .#.##.