Add solution to 2025-12-07

Author: fuglede

2025/day07/solutions.py

@@ -0,0 +1,36 @@
+"""Solution by ordinary BFS."""
+
+from collections import defaultdict, deque
+
+with open("input") as f:
+    ls = f.read().strip().split("\n")
+
+board = {i + 1j * j: x for i, l in enumerate(ls) for j, x in enumerate(l)}
+S = next(z for z, x in board.items() if x == "S")
+histories = defaultdict(int, {S: 1})
+
+beam = deque([S])
+seen = {S}
+splits = 0
+while beam:
+    laser = beam.popleft()
+    nxt = laser + 1
+    if nxt in seen or nxt not in board:
+        continue
+    seen.add(nxt)
+    if board[nxt] == "^":
+        beam += [nxt - 1j, nxt + 1j]
+        histories[nxt - 1j] += histories[laser]
+        histories[nxt + 1j] += histories[laser]
+        splits += 1
+    else:
+        beam.append(nxt)
+        histories[nxt] += histories[laser]
+
+# Part 1
+print(splits)
+
+# Part 2
+max_real = max(z.real for z in board)
+bottom = [z for z in board if z.real == max_real]
+print(sum(histories[b] for b in bottom))

2025/day07/solutions2.py

@@ -0,0 +1,30 @@
+"""Solution by treating each splitter individually.
+
+Here, we note that how many beams enter a splitter depends only on the
+ones above it, and immediately to its left/right. Moreover, once we find
+a splitter directly above a given splitter, we now that we can stop
+looking further up that column, since that splitter will block any beams
+from higher up.
+
+By noting that no two splitters are ever horizontally adjacent, we can
+simplify the iteration logic a good deal.
+"""
+
+with open("input") as f:
+    ls = f.read().strip().split("\n")
+
+splitters = [col for l in ls for col, x in enumerate(l) if x == "^"]
+entering = [1] + [0] * (len(splitters) - 1)
+
+for i, si in enumerate(splitters):
+    for j, sj in enumerate(splitters[:i][::-1]):
+        if si == sj:
+            break
+        if abs(si - sj) == 1:
+            entering[i] += entering[i - j - 1]
+
+# Part 1
+print(sum(b > 0 for b in entering))
+
+# Part 2
+print(sum(entering) + 1)