Solve 2025 day 7

.gitignore

@@ -4,6 +4,8 @@
 __pycache__/
 *.py[cod]
 *$py.class
+.python-version
+uv.lock
 
 # C extensions
 *.so

2024/d10.py

@@ -0,0 +1,26 @@
+from collections import deque
+from lib import Grid2D
+from lib import get_data
+
+
+data = get_data(__file__)
+g = Grid2D(data)
+
+p1 = 0
+p2 = 0
+for start in g.find("0"):
+    queue = deque([start])
+    all = set()
+    while queue:
+        node = queue.popleft()
+        if g[node] == "9":
+            all.add(node)
+            p2 += 1
+
+        for nb in g.neighbors_ort(node):
+            if int(g[node]) + 1 == int(g[nb]):
+                queue.append(nb)
+    p1 += len(all)
+
+print(p1)
+print(p2)

2024/d11.py

@@ -0,0 +1,31 @@
+from lib import get_data
+from lib import ints
+
+data = get_data(__file__)
+xs = ints(data)
+CACHE = {}
+
+# I had maxsize too small at first :/
+# @lru_cache(maxsize=10**12) 
+def apply(x, rest):
+    if rest == 0:
+        return 1
+
+    if (x, rest) in CACHE:
+        return CACHE[(x, rest)]
+
+    if x == 0:
+        r = apply(1, rest - 1)
+    elif len(str(x)) % 2 == 0:
+        sx = str(x)
+        a = int(sx[: len(sx) // 2])
+        b = int(sx[len(sx) // 2 :])
+        r = apply(a, rest - 1) + apply(b, rest - 1)
+    else:
+        r = apply(x * 2024, rest - 1)
+    CACHE[(x, rest)] = r
+    return r
+
+
+print(sum([apply(x, 25) for x in xs]))
+print(sum([apply(x, 75) for x in xs]))

2024/d12.py

@@ -0,0 +1,61 @@
+from lib import get_data
+from lib import Grid2D
+from collections import defaultdict
+from collections import deque
+
+data = get_data(__file__)
+
+DIRS = {
+    "N": (-1, 0),
+    "E": (0, 1),
+    "S": (1, 0),
+    "W": (0, -1),
+}.values()
+
+
+g = Grid2D(data)
+cs = defaultdict(set)
+for row in range(g.n_rows):
+    for col in range(g.n_cols):
+        c = g[(row, col)]
+        cs[c].add((row, col))
+
+t1, t2 = 0, 0
+for c, cs in cs.items():
+    while cs:
+        peri = 0
+        start = cs.pop()
+        seen = set()
+        queue = deque([start])
+        fences = set()
+        while queue:
+            pos = queue.popleft()
+            if pos in seen:
+                continue
+            seen.add(pos)
+
+            for d in DIRS:
+                nb = d[0] + pos[0], d[1] + pos[1]
+                if g.contains(nb) and g[nb] == c:
+                    queue.append(nb)
+                    cs.discard(nb)
+                else:
+                    peri += 1
+                    nb = tuple(list(nb) + [d])
+                    fences.add(nb)
+
+        nfences = set()
+        for row, col, dir in fences:
+            for dr, dc in [(1, 0), (0, 1)]:
+                nr, nc = row + dr, col + dc
+                if (nr, nc, dir) in fences:
+                    break
+            else:
+                nfences.add((row, col, dir))
+
+        c_area = len(seen)
+        t1 += c_area * peri
+        t2 += c_area * len(nfences)
+
+print(t1)
+print(t2)

2024/d13.py

@@ -0,0 +1,33 @@
+from lib import get_data
+from lib import ints
+
+data = get_data(__file__)
+ps = data.split("\n\n")
+
+c1, c2 = 0, 0
+for p in ps:
+    lines = p.splitlines()
+    ax, ay = ints(lines[0])
+    bx, by = ints(lines[1])
+    px, py = ints(lines[2])
+    px2 = px + 10000000000000
+    py2 = py + 10000000000000
+
+    for a in range(0, 101):
+        for b in range(0, 101):
+            if a * ax + b * bx == px and a * ay + b * by == py:
+                c1 += a * 3 + b
+
+    D = ax * by - bx * ay
+    if abs(D) > 1e-10:
+        a_ = px2 * by - bx * py2
+        b_ = ax * py2 - px2 * ay
+        if a_ % D == 0 and b_ % D == 0:
+            a = (px2 * by - bx * py2) // D
+            b = (ax * py2 - px2 * ay) // D
+
+            if a >= 0 and b >= 0:
+                c2 += a * 3 + b
+
+print(c1)
+print(c2)

2024/d14.py

@@ -0,0 +1,64 @@
+from lib import get_data
+from lib import ints
+from collections import defaultdict
+
+rows = 103
+cols = 101
+data = get_data(__file__)
+
+
+def score(robots):
+    quadrants = defaultdict(int)
+    for _, r, c in robots:
+        if r < rows // 2 and c < cols // 2:
+            quadrants[1] += 1
+        elif r < rows // 2 and c > cols // 2:
+            quadrants[2] += 1
+        elif r > rows // 2 and c < cols // 2:
+            quadrants[3] += 1
+        elif r > rows // 2 and c > cols // 2:
+            quadrants[4] += 1
+    t = 1
+    for q in quadrants.values():
+        t *= q
+    return t
+
+
+def print_from_xy(xs):
+    x_min = min(v[1] for v in xs)
+    x_max = max(v[1] for v in xs)
+    y_min = min(v[0] for v in xs)
+    y_max = max(v[0] for v in xs)
+    for y in range(y_min, y_max + 1):
+        row = ""
+        for x in range(x_min, x_max + 1):
+            if (x, y) in xs:
+                row += "#"
+            else:
+                row += " "
+        print(row)
+
+
+robots_speed = {}
+robots = list()
+for i, line in enumerate(data.splitlines()):
+    c, r, vc, vr = ints(line)
+    robots_speed[i] = (vr, vc)
+    robots.append((i, r, c))
+
+for j in range(rows * cols):
+    nrobots = list()
+    count = 0
+    for i, r, c in robots:
+        vr, vc = robots_speed[i]
+        nr = (r + vr) % rows
+        nc = (c + vc) % cols
+        nrobots.append((i, nr, nc))
+    robots = nrobots
+    if j == 99:
+        print(score(robots))
+    robots_coords = [(r, c) for _, r, c in robots]
+    if len(robots_coords) == len(set(robots_coords)):
+        print(j + 1)
+        # print_from_xy(robots_coords)
+        break

2024/d15.py

@@ -0,0 +1,92 @@
+from lib import get_data
+from lib import Grid2D
+
+DIRS = {
+    "^": (-1, 0),
+    ">": (0, 1),
+    "v": (1, 0),
+    "<": (0, -1),
+}
+
+data = get_data(__file__)
+data, moves = data.split("\n\n")
+
+g = Grid2D(data)
+
+
+def simulate(grid: Grid2D, moves: str):
+    (p,) = g.find("@")
+    for c in moves:
+        if c == "\n":
+            continue
+        d = DIRS[c]
+
+        to_move = set([p])
+        row = to_move
+        blocked = False
+        while True:
+            nrow = set()
+            for (
+                r,
+                c,
+            ) in row:
+                np = r + d[0], c + d[1]
+                if g[np] == "#":
+                    blocked = True
+                elif g[np] == "O":
+                    nrow.add(np)
+                elif g[np] == "[":
+                    nrow.add(np)
+                    if d == (1, 0) or d == (-1, 0):
+                        nrow.add((np[0], np[1] + 1))
+                elif g[np] == "]":
+                    if d == (1, 0) or d == (-1, 0):
+                        nrow.add((np[0], np[1] - 1))
+                    nrow.add(np)
+            to_move |= row
+            row = nrow
+            if len(row) == 0 or blocked:
+                break
+
+        if not blocked:
+            to_place = {}
+            p = p[0] + d[0], p[1] + d[1]
+
+            for tm in to_move:
+                np = tm[0] + d[0], tm[1] + d[1]
+                to_place[np] = g[tm]
+                g[tm] = "."
+
+            for pos, c in to_place.items():
+                g[pos] = c
+
+
+def score(g: Grid2D) -> int:
+    os = g.find("O")
+    if os:
+        return sum(r * 100 + c for r, c in os)
+    return sum(r * 100 + c for r, c in g.find("["))
+
+
+simulate(g, moves)
+print(score(g))
+
+ndata = ""
+for c in data:
+    if c == "#":
+        ndata += "##"
+    elif c == "O":
+        ndata += "[]"
+    elif c == ".":
+        ndata += ".."
+    elif c == "@":
+        ndata += "@."
+    else:
+        ndata += c
+
+g = Grid2D(ndata)
+(p,) = g.find("@")
+
+simulate(g, moves)
+print(score(g))
+exit()

2024/d16.py

@@ -0,0 +1,96 @@
+import heapq
+from collections import defaultdict
+from lib import get_data
+from lib import Grid2D
+
+
+data = get_data(__file__)
+
+g = Grid2D(data)
+
+
+def search(start, end, dir):
+    paths = set()
+
+    def reconstruct(parents, current):
+        seen = set()
+        to_visit = [current]
+        while to_visit:
+            current = to_visit.pop()
+            if current in seen:
+                continue
+            seen.add(current)
+            paths.add(current[0])
+            for p in parents[current]:
+                to_visit.append(p)
+
+    def dist(n1, n2):
+        """cost from node to node"""
+        if n1 == 0 or n1 == n2:
+            return 0
+        p1, d1 = n1
+        p2, d2 = n2
+        if p1 != p2:
+            return 1
+        if d1 != d2:
+            return 1000
+        assert False
+
+    def h(node):
+        """heuristic function (never overestimate)"""
+        pos = node[0]
+        return abs(pos[0] - end[0]) + abs(pos[1] - end[1])
+
+    def is_goal(node):
+        return node[0] == end
+
+    def neighbors(node):
+        pos, dir = node
+        npos = pos[0] + dir[0], pos[1] + dir[1]
+        nbs = []
+        if g.contains(npos) and g[npos] != "#":
+            nbs.append((npos, dir))
+        ndir = dir[1], -dir[0]
+        nbs.append((pos, ndir))
+        ndir = -dir[1], dir[0]
+        nbs.append((pos, ndir))
+        return nbs
+
+    starts = [(start, dir)]
+    open_set = []
+    g_score = {}
+    cost = None
+
+    for start in starts:
+        heapq.heappush(open_set, (h(start), start))
+        g_score[start] = dist(0, start)
+
+    parents = defaultdict(list)
+    while open_set:
+        current_f_score, current = heapq.heappop(open_set)
+        if is_goal(current):
+            # assert current_f_score == g_score[current]
+            gs = g_score[current]
+            if cost is None or gs <= cost:
+                cost = gs
+                reconstruct(parents, current)
+            else:
+                break
+
+        for neighbor in neighbors(current):
+            tentative_g_score = g_score[current] + dist(current, neighbor)
+            if tentative_g_score <= g_score.get(neighbor, 10**12):
+                parents[neighbor].append(current)
+                g_score[neighbor] = tentative_g_score
+                f_score = g_score[neighbor] + h(neighbor)
+                heapq.heappush(open_set, (f_score, neighbor))
+    return cost, paths
+
+
+(start,) = g.find("S")
+(end,) = g.find("E")
+dir = (0, 1)
+
+cost, paths = search(start, end, dir)
+print(cost)
+print(len(paths))

2024/d17.py

@@ -0,0 +1,61 @@
+from lib import get_data
+from lib import ints
+
+
+data = get_data(__file__)
+nums, prog = data.split("\n\n")
+regs = ints(nums)
+prog = ints(prog)
+
+i = 0
+out = []
+while i < len(prog) - 1:
+    inst, op = prog[i], prog[i + 1]
+    assert op != 7
+    combo = op if op not in [4, 5, 6] else regs[op - 4]
+    literal = op
+    match inst:
+        case 0:
+            regs[0] = regs[0] >> combo
+        case 1:
+            regs[1] = regs[1] ^ literal
+        case 2:
+            regs[1] = combo % 8
+        case 3:
+            if regs[0] != 0:
+                i = literal - 2
+        case 4:
+            regs[1] = regs[1] ^ regs[2]
+        case 5:
+            out.append(combo % 8)
+        case 6:
+            regs[1] = regs[0] // (2**combo)
+        case 7:
+            regs[2] = regs[0] // (2**combo)
+        case _:
+            assert False
+    i += 2
+
+print(",".join(map(str, out)))
+
+
+def get_a(a_current, xs):
+    if len(xs) == 0:
+        return [a_current // 8]
+    x = xs[0]
+    aan = []
+    for a_new in range(8):
+        a = a_current + a_new
+        b = a % 8
+        assert b == a_new
+        b = b ^ 1
+        c = a >> b
+        b = b ^ c
+        b = b ^ 5
+        if (b % 8) == x:
+            aan += get_a(a << 3, xs[1:])
+    return aan
+
+
+aa = get_a(0, list(reversed(prog)))
+print(min(aa))

2024/d18.py

@@ -0,0 +1,67 @@
+import heapq
+from lib import get_data
+from lib import ints
+from lib import Grid2D
+
+data = get_data(__file__)
+
+size = 71
+grid = "\n".join(["." * size for _ in range(size)])
+
+g = Grid2D(grid)
+for i, line in enumerate(data.splitlines()):
+    x, y = ints(line)
+    g[(y, x)] = "x"
+
+    start = (0, 0)
+    end = (size - 1, size - 1)
+
+    def dist(n1, n2):
+        """cost from node to node"""
+        if n1 == 0 or n1 == n2:
+            return 0
+        return 1
+
+    def h(node):
+        """heuristic function (never overestimate)"""
+        return abs(node[0] - end[0]) + abs(node[1] - end[1])
+
+    def is_goal(node):
+        return node == end
+
+    def neighbors(node):
+        nbs = []
+        for nb in g.neighbors_ort(node):
+            if g[nb] != "x":
+                nbs.append(nb)
+        return nbs
+
+    starts = [start]
+    open_set = []
+    g_score = {}
+    cost = None
+
+    for start in starts:
+        heapq.heappush(open_set, (h(start), start))
+        g_score[start] = dist(0, start)
+
+    while open_set:
+        current_f_score, current = heapq.heappop(open_set)
+        if is_goal(current):
+            assert current_f_score == g_score[current]
+            cost = g_score[current]
+            break
+
+        for neighbor in neighbors(current):
+            tentative_g_score = g_score[current] + dist(current, neighbor)
+            if neighbor not in g_score or tentative_g_score < g_score[neighbor]:
+                g_score[neighbor] = tentative_g_score
+                f_score = g_score[neighbor] + h(neighbor)
+                heapq.heappush(open_set, (f_score, neighbor))
+
+    if i == 1023:
+        print(cost)
+
+    if cost is None:
+        print(line)
+        break

2024/d19.py

@@ -0,0 +1,30 @@
+from lib import get_data
+from functools import cache
+
+data = get_data(__file__)
+lines = data.splitlines()
+patterns = set(lines[0].split(", "))
+
+
+@cache
+def valid(line):
+    if line == "":
+        return 1
+    r = 0
+    for j in range(1, len(line) + 1):
+        sub = line[:j]
+        if sub in patterns:
+            r += valid(line[j:])
+    return r
+
+
+p1, p2 = 0, 0
+lines = lines[2:]
+for line in lines:
+    v = valid(line.strip())
+    if v > 0:
+        p1 += 1
+        p2 += v
+
+print(p1)
+print(p2)

2024/d20.py

@@ -0,0 +1,90 @@
+from collections import deque
+from lib import get_data
+from lib import Grid2D
+
+
+data = """###############
+#...#...#.....#
+#.#.#.#.#.###.#
+#S#...#.#.#...#
+#######.#.#.###
+#######.#.#...#
+#######.#.###.#
+###..E#...#...#
+###.#######.###
+#...###...#...#
+#.#####.#.###.#
+#.#...#.#.#...#
+#.#.#.#.#.#.###
+#...#...#...###
+###############
+"""
+data = get_data(__file__)
+
+g = Grid2D(data)
+
+(start,) = g.find("S")
+(end,) = g.find("E")
+
+cost = 0
+sd = dict()
+de = dict()
+
+queue = deque([(start[0], start[1], 0)])
+seen = set()
+while queue:
+    r, c, cost = queue.popleft()
+
+    if (r, c) in sd:
+        continue
+    sd[(r, c)] = cost
+
+    if (r, c) == end:
+        break
+
+    for r, c in g.neighbors_ort((r, c)):
+        if g[(r, c)] != "#":
+            queue.append((r, c, cost + 1))
+
+seen = set()
+queue = deque([(end[0], end[1], 0)])
+while queue:
+    r, c, cost = queue.popleft()
+
+    if (r, c) in de:
+        continue
+    de[(r, c)] = cost
+
+    if (r, c) == start:
+        break
+
+    for r, c in g.neighbors_ort((r, c)):
+        if g[(r, c)] != "#":
+            queue.append((r, c, cost + 1))
+
+for max_steps in [2, 20]:
+    cheats = set()
+    for cr, cc in g.find("S."):
+        start = cr, cc, 0
+        seen = set()
+        queue = deque([start])
+        while queue:
+            r, c, steps = queue.popleft()
+            if steps > max_steps:
+                continue
+
+            if (r, c) in seen:
+                continue
+            seen.add((r, c))
+
+            if g[(r, c)] != "#":
+                ncost = sd[(cr, cc)] + steps + de[(r, c)]
+                if cost - ncost >= 100:
+                    cheats.add((cr, cc, r, c))
+
+            for dr, dc in [(-1, 0), (0, 1), (1, 0), (0, -1)]:
+                nr, nc = r + dr, c + dc
+                if g.contains((nr, nc)):
+                    queue.append((nr, nc, steps + 1))
+
+    print(len(cheats))

2024/d21.py

@@ -0,0 +1,87 @@
+from lib import get_data
+from collections import deque
+from functools import cache
+
+
+data = get_data(__file__)
+# data = """029A
+# 980A
+# 179A
+# 456A
+# 379A"""
+
+
+def new_dir(current, move):
+    return {
+        "<": {">": "v"},
+        "^": {">": "A", "v": "v"},
+        "v": {"<": "<", ">": ">", "^": "^"},
+        ">": {"^": "A", "<": "v"},
+        "A": {"<": "^", "v": ">"},
+    }[current].get(move, None)
+
+
+def new_num(current, move):
+    return {
+        "7": {">": "8", "v": "4", },
+        "8": {"<": "7", ">": "9", "v": "5"},
+        "9": {"<": "8", "v": "6"},
+        "4": {"^": "7", ">": "5", "v": "1"},
+        "5": {"^": "8", ">": "6", "<": "4", "v": "2"},
+        "6": {"^": "9", "<": "5", "v": "3"},
+        "1": {"^": "4", ">": "2"},
+        "2": {"^": "5", ">": "3", "<": "1", "v": "0"},
+        "3": {"^": "6", "<": "2", "v": "A"},
+        "0": {"^": "2", ">": "A"},
+        "A": {"^": "3", "<": "0"},
+    }[current].get(move, None)
+
+
+@cache
+def find(code, depth, lookup):
+    if depth == 0:
+        return len(code)
+    code = list(code)
+    t = 0
+    current = "A"
+    while code:
+        solutions = []
+        target = code.pop(0)
+        start = (current, "")
+        seen = set()
+        queue = deque([start])
+        while queue:
+            node = queue.popleft()
+            if node in seen:
+                continue
+            seen.add(node)
+            if node[0] == target:
+                solution = node[1] + "A"
+                if len(solutions) == 0:
+                    solutions.append(solution)
+                elif len(solutions[-1]) == len(solution):
+                    solutions.append(solution)
+                else:
+                    break
+                continue
+
+            for c in "<>v^":
+                next = lookup(node[0], c)
+                if next is not None:
+                    queue.append((next, node[1] + c))
+        current = target
+        t += min(find(code, depth - 1, new_dir) for code in solutions)
+    return t
+
+
+p1, p2 = 0, 0
+for line in data.splitlines():
+    i = int("".join([c for c in line if c.isdigit()]))
+    s1 = find(line, 3, new_num)
+    s2 = find(line, 26, new_num)
+    p1 += s1 * i
+    p2 += s2 * i
+
+
+print(p1)
+print(p2)

2024/d22.py

@@ -0,0 +1,56 @@
+from lib import get_data
+from lib import ints
+from collections import defaultdict
+
+
+data = get_data(__file__)
+
+
+def secret(x):
+    x ^= x * 64
+    x %= 16777216
+
+    x ^= x // 32
+    x %= 16777216
+
+    x ^= x * 2048
+    x %= 16777216
+    return x
+
+
+def slice(xs, n):
+    return [slice for slice in zip(*[xs[i:] for i in range(n)])]
+
+
+codes = defaultdict(int)
+
+
+def int_seq(x):
+    xs = []
+    for _ in range(2000):
+        xs.append(x % 10)
+        x = secret(x)
+    ds = [a - b for a, b in zip(xs[1:], xs)]
+
+    seen = set()
+    for s in slice(list(zip(xs[1:], ds)), 4):
+        code = tuple([e[1] for e in s])
+        v = s[-1][0]
+        if not code in seen:
+            codes[code] += v
+            seen.add(code)
+
+
+for line in data.splitlines():
+    (x,) = ints(line)
+
+s = 0
+for line in data.splitlines():
+    (x,) = ints(line)
+    int_seq(x)
+    for _ in range(2000):
+        x = secret(x)
+    s += x
+
+print(s)
+print(max(codes.values()))

2024/d23.py

@@ -0,0 +1,43 @@
+from lib import get_data
+from collections import defaultdict
+
+data = get_data(__file__)
+g = defaultdict(set)
+
+for line in data.splitlines():
+    a, b = line.split("-")
+    g[a].add(b)
+    g[b].add(a)
+
+
+cs = set()
+for a, bs in g.items():
+    for b in bs:
+        for c in g[b]:
+            if c in bs:
+                cs.add(tuple(sorted([a, b, c])))
+
+cs = [t for t in cs if any(x.startswith("t") for x in t)]
+print(len(cs))
+
+
+def find_largest_clique(graph):
+    def bron_kerbosch(r, p, x, max_clique):
+        if not p and not x:
+            if len(r) > len(max_clique[0]):
+                max_clique[0] = r.copy()
+            return
+
+        for v in p.copy():
+            neighbors = graph[v]
+            bron_kerbosch(r | {v}, p & neighbors, x & neighbors, max_clique)
+            p.remove(v)
+            x.add(v)
+
+    max_clique = [set()]
+    bron_kerbosch(set(), set(graph.keys()), set(), max_clique)
+    return max_clique[0]
+
+
+cs = find_largest_clique(g)
+print(",".join(sorted(cs)))

2024/d24.py

@@ -0,0 +1,143 @@
+from lib import get_data
+from lib import ints
+
+LHS, OP, RHS, _, OUT = 0, 1, 2, 3, 4
+
+
+def run(states, gates):
+    change = True
+    while change:
+        change = False
+        for gate in gates:
+            i1, op, i2, _, out = gate
+            if i1 in states and i2 in states and out not in states:
+                change = True
+                outv = None
+                match op:
+                    case "OR":
+                        outv = states[i1] | states[i2]
+                    case "XOR":
+                        outv = states[i1] ^ states[i2]
+                    case "AND":
+                        outv = states[i1] & states[i2]
+                assert outv is not None
+                states[out] = outv
+
+    i, t = 0, 0
+    while True:
+        si = f"z{i:02}"
+        if not si in states:
+            break
+        if states[si]:
+            t += 2**i
+        i += 1
+    return t
+
+
+data = get_data(__file__)
+
+s1, s2 = data.split("\n\n")
+states = {}
+for line in s1.splitlines():
+    gate, value = line.split(": ")
+    states[gate] = int(value)
+
+gates = []
+out_to_index = {}
+xors = {}
+zz = []
+for i, line in enumerate(s2.splitlines()):
+    o1, op, o2, _, out = line.split()
+    o1, o2 = sorted([o1, o2])
+    gate = [o1, op, o2, "->", out]
+    gates.append(gate)
+    out_to_index[out] = i
+    if out.startswith("z"):
+        zz.append(out)
+    if op == "XOR" and o1.startswith("x"):
+        (index,) = ints(o1)
+        xors[index] = gate
+
+p1 = run(states, gates)
+print(p1)
+
+NUMBER_Z_GATES = ints(sorted(zz)[-1])[0] + 1
+# print(NUMBER_Z_GATES)
+# pprint(xors)
+
+xx = [f"x{i:02}" for i in range(NUMBER_Z_GATES - 1)]
+yy = [f"y{i:02}" for i in range(NUMBER_Z_GATES - 1)]
+
+# def resolve(x):
+#     if x in xx or x in yy:
+#         return f"{x}"
+#         # return x
+#     a, op, b = gate_to_in[x]
+#     aa = resolve(a)
+#     bb = resolve(b)
+#     # print(aa, bb)
+#     aa, bb = sorted([aa, bb], reverse=True)
+#     op = "^" if op == "XOR" else ("|" if op == "OR" else "&")
+#     return f"({aa} {op} {bb})"
+#     # return [aa, op, bb]
+
+
+def find_xor(index):
+    xor = xors[index][OUT]
+    for gate in gates:
+        if gate[OP] == "XOR" and (gate[LHS] == xor or gate[RHS] == xor):
+            return gate
+    return None
+
+
+corrected = []
+for i in range(NUMBER_Z_GATES):
+    sx, sy, sz = [f"{c}{i:02}" for c in "xyz"]
+    gate = gates[out_to_index[sz]]
+    if i == 0:
+        assert gate == xors[i]
+    elif i == NUMBER_Z_GATES - 1:
+        pass  # last gate needs special check
+    else:
+        fixed = False
+        xor = xors[i]
+        if gate[OP] != "XOR":
+            cgate = find_xor(i)
+            assert cgate is not None
+            gate[OUT], cgate[OUT] = cgate[OUT], gate[OUT]
+            corrected.append(gate[OUT])
+            corrected.append(cgate[OUT])
+            out_to_index[gate[OUT]], out_to_index[cgate[OUT]] = (
+                out_to_index[cgate[OUT]],
+                out_to_index[gate[OUT]],
+            )
+            fixed = True
+            # print(f"[swap] {gate} <-> {cgate}")
+            gate = gates[out_to_index[sz]]
+        assert gate[OP] == "XOR"
+
+        # print(gate)
+        i_lhs, i_rhs = out_to_index[gate[LHS]], out_to_index[gate[RHS]]
+        a, b = gates[i_lhs], gates[i_rhs]
+
+        if a == xor:
+            # print(f"[ok] {sz} ({fixed})")
+            pass
+        elif b == xor:
+            # print(f"[ok] {sz} ({fixed})")
+            gate[0], gate[2] = gate[2], gate[0]
+        else:
+            if a[OP] == "AND":
+                a[OUT], xor[OUT] = xor[OUT], a[OUT]
+                corrected.append(a[OUT])
+                corrected.append(xor[OUT])
+                # print(f"[swap] {a} <-> {xor}")
+                out_to_index[a[OUT]], out_to_index[xor[OUT]] = (
+                    out_to_index[xor[OUT]],
+                    out_to_index[a[OUT]],
+                )
+                # print(f"[ok] {sz} (manual fix)")
+            else:
+                print(f"[nok] {sz} (don't know how to fix)")
+
+print(",".join(sorted(corrected)))

2024/d25.py

@@ -0,0 +1,25 @@
+from lib import get_data
+from lib import Grid2D
+
+data = get_data(__file__)
+
+locks = []
+keys = []
+
+for o in data.split("\n\n"):
+    g = Grid2D(o)
+    if all(g[(0, c)] == "#" for c in range(g.n_cols)):
+        keys.append(g)
+    elif all(g[g.n_rows - 1, c] == "#" for c in range(g.n_cols)):
+        locks.append(g)
+    else:
+        assert False
+
+t = 0
+for key in keys:
+    for lock in locks:
+        k = key.find("#")
+        l = lock.find("#")
+        if len(k) + len(l) == len(set(k) | set(l)):
+            t += 1
+print(t)

2025/d01.py

@@ -0,0 +1,22 @@
+from lib import get_data
+
+NUM = 100
+
+data = get_data(__file__)
+
+pos = 50
+r1, r2 = 0, 0
+for line in data.splitlines():
+    d = line[0]
+    n = int(line[1:])
+    dir = 1 if d == "R" else -1
+
+    for _ in range(n):
+        pos = (pos + dir) % NUM
+        if pos == 0:
+            r2 += 1
+    if pos == 0:
+        r1 += 1
+
+print(r1)
+print(r2)

2025/d02.py

@@ -0,0 +1,34 @@
+from lib import get_data
+
+
+data = get_data(__file__)
+
+def is_invalid(xs: str) -> bool:
+    for seq_len in range(1, len(xs) // 2 + 1):
+        if xs[:seq_len] == xs[seq_len:]:
+            return True
+    return False
+
+def is_invalid2(xs: str) -> bool:
+    for seq_len in range(1, len(xs)):
+        if len(xs) % seq_len != 0:
+            continue
+        for repeat in range(len(xs) // seq_len):
+            i = seq_len * repeat
+            if xs[:seq_len] != xs[i:i + seq_len]:
+                break
+        else:
+            return True
+    return False
+
+r1, r2 = 0, 0
+for id_range in data.split(","):
+    lo, up = list(map(int, id_range.split("-")))
+    for id in range(lo, up + 1):
+        if is_invalid(str(id)):
+            r1 += id
+        if is_invalid2(str(id)):
+            r2 += id
+
+print(r1)
+print(r2)

2025/d03.py

@@ -0,0 +1,34 @@
+from lib import get_data
+
+data = get_data(__file__)
+
+
+def max_joltage(xs: str, target_len: int) -> int:
+    def dynamic(xs: str) -> dict[int, str]:
+        if len(xs) == 0:
+            return {0: ""}
+
+        rs = dynamic(xs[1:])
+        for i in range(target_len, 0, -1):
+            if not (i - 1) in rs:
+                continue
+            nv = int(xs[0] + rs[i - 1])
+            if not i in rs:
+                rs[i] = str(nv)
+            elif nv > int(rs[i]):
+                rs[i] = str(nv)
+        return rs
+
+    rs = dynamic(xs)
+    return int(rs[target_len])
+
+
+r1 = 0
+r2 = 0
+for line in data.splitlines():
+    r1 += max_joltage(line, 2)
+    r2 += max_joltage(line, 12)
+
+
+print(r1)
+print(r2)

2025/d04.py

@@ -0,0 +1,32 @@
+from lib import get_data, Grid2D
+
+data = get_data(__file__)
+g = Grid2D(data)
+
+r = 0
+adjs = []
+for pos in g.all_coords():
+    if g[pos] != "@":
+        continue
+    nr_of_rolls_adj = len([nb for nb in g.neighbors_adj(pos) if g[nb] == "@"])
+    if nr_of_rolls_adj < 4:
+        r += 1
+        adjs.append(pos)
+print(r)
+
+r = 0
+while True:
+    adjs = []
+    for pos in g.all_coords():
+        if g[pos] != "@":
+            continue
+        nr_of_rolls_adj = len([nb for nb in g.neighbors_adj(pos) if g[nb] == "@"])
+        if nr_of_rolls_adj < 4:
+            adjs.append(pos)
+    if adjs:
+        r += len(adjs)
+        for a in adjs:
+            g[a] = "."
+    else:
+        break
+print(r)

2025/d05.py

@@ -0,0 +1,45 @@
+from lib import get_data
+
+data = get_data(__file__)
+
+ranges, ids = data.split("\n\n")
+ids = tuple(map(int, ids.splitlines()))
+ranges = [list(map(int, line.split("-"))) for line in ranges.splitlines()]
+
+updated = True
+while updated:
+    updated = False
+    sorted_ranges = []
+    for lo, up in ranges:
+        assert lo <= up
+        for i in range(len(sorted_ranges)):
+            slo, sup = sorted_ranges[i]
+            if up + 1 < slo:
+                sorted_ranges.insert(i, (lo, up))
+            elif lo < slo:
+                sorted_ranges[i] = (lo, max(up, sup))
+                updated = True
+            elif lo <= sup:
+                sorted_ranges[i] = (slo, max(up, sup))
+                updated = True
+            else:
+                continue
+            break
+        else:
+            sorted_ranges.append((lo, up))
+    ranges = sorted_ranges
+
+
+result_part_1 = 0
+for id_to_check in ids:
+    for lo, up in ranges:
+        if lo <= id_to_check <= up:
+            result_part_1 += 1
+            break
+print(result_part_1)
+
+result_part_2 = 0
+for lo, up in ranges:
+    result_part_2 += up - lo + 1
+print(result_part_2)
+assert result_part_2 == 350780324308385

2025/d06.py

@@ -0,0 +1,60 @@
+from lib import get_data
+from typing import TypeVar
+
+T = TypeVar('T')
+
+data = """123 328  51 64 
+ 45 64  387 23 
+  6 98  215 314
+*   +   *   +  """
+data = get_data(__file__)
+
+def mul(xs):
+    r = 1
+    for x in xs:
+        r *= x
+    return r
+
+lines = zip(*[line.split() for line in data.splitlines()])
+
+r = 0
+for xs in lines:
+    xs, op = xs[:-1], xs[-1]
+    xs = list(map(int, xs))
+    if op == "+":
+        r += sum(xs)
+    elif op == "*":
+        r += mul(xs)
+    else:
+        assert False, "Unexpected op"
+print(r)
+
+def split(xs: list[T], delim: T) -> list[list[T]]:
+    res = [[]]
+    for x in xs:
+        if x == delim:
+            res.append([])
+        else:
+            res[-1].append(x)
+    return res
+
+chars_trans: list[tuple[str]]  = list(zip(*[line for line in data.splitlines()]))
+lines_trans: list[str] = list(map(lambda line: "".join(line).strip(), chars_trans))
+cols: list[list[str]] = split(lines_trans, '')
+
+r2 = 0
+for xs in cols:
+    x0 = xs[0]
+    acc, op = int(x0[:-1]), x0[-1]
+    for x in xs[1:]:
+        x = int(x)
+        if op == "+":
+            acc += x
+        elif op == "*":
+            acc *= x
+        else:
+            assert False, "Unexpected op"
+    r2 += acc
+
+print(r2)
+

2025/d07.py

@@ -0,0 +1,59 @@
+from lib import get_data, Grid2D
+from collections import defaultdict
+
+
+data = """.......S.......
+...............
+.......^.......
+...............
+......^.^......
+...............
+.....^.^.^.....
+...............
+....^.^...^....
+...............
+...^.^...^.^...
+...............
+..^...^.....^..
+...............
+.^.^.^.^.^...^.
+..............."""
+data = get_data(__file__)
+
+g = Grid2D(data)
+beams = [g.find('S')[0][1]]
+
+splits = 0
+for row in range(1, g.n_rows - 1):
+    new_beams = set()
+    for beam in beams:
+        field = g[(row, beam)]
+        if field == "^":
+            splits += 1
+            new_beams.add(beam - 1)
+            new_beams.add(beam + 1)
+        elif field == ".":
+            new_beams.add(beam)
+        else:
+            assert False, "unexpected field"
+    beams = list(new_beams)
+    # print(beams)
+
+print(splits)
+
+beams = {g.find('S')[0][1]: 1}
+for row in range(1, g.n_rows - 1):
+    new_beams = defaultdict(int)
+    for beam, count in beams.items():
+        field = g[(row, beam)]
+        if field == "^":
+            new_beams[beam - 1] += count
+            new_beams[beam + 1] += count
+        elif field == ".":
+            new_beams[beam] += count
+        else:
+            assert False, "unexpected field"
+    beams = new_beams
+
+print(sum(beams.values()))
+

2025/lib.py

@@ -0,0 +1 @@
+../lib.py

README.md

@@ -2,244 +2,60 @@
 
 Solutions and utility script for Advent of Code challenges in Python.
 
-## AoC 2015
+## AoC 2025
 
-- Day 1: 3:10
-- Day 2: 5:24 :/ 
-- Day 3: 7:26 ... :/
-- Day 4: 5:11 ...
-- Day 5: 14:05 o.O
-- Day 6: 15:00
-- Day 7: 17:00
-- Day 8: 14:55
-- Day 9: 13:48
-- Day 10: 70:00 ... slow, but fun
-- Day 11: 12:30
-- Day 12: 6:03
-- Day 13: 7:06 (would have been first by a minute, probably 70ish in 2023)
-- Day 14: 27:45 ... that was weak, logic error for part 2 :/
-- Day 15: 16:00 I should probably stop brute forcing these optimization problems
-- Day 16: 19:00
-- Day 17: 9:05
-- Day 18: 10:39
-- Day 19: Many days... yeah this one took me way too long to figure out
-- Day 20: 10:54
-- Day 21: 25:52 cute bug where I didn't consider that no armor is an option
-- Day 22: That was bad. Did not know how to choose between dfs/bfs and logic errors.
-- Day 23: 10:00
-- Day 24: 20:00 ugly - recursive solution would be more elegant
-- Day 25: 9:34
+Only twelve problems and no leaderboard this year. That means life will be less
+stressful and this will actually be more fun. Thank you Eric Wastl and let's go!
 
-## AoC 2016
+- Day 1: Maybe the hardest day 1 part 2 ever for me? I struggled to calculate
+  the number of ticks on 0 directly and ended up just iterating over all the
+  ticks naively. Maybe I should revisit this.
+- Day 2: The simple direct approach with iterating over all the IDs in the
+  ranges just worked okay. Not pretty but acceptable.
+- Day 3: Fun dynamic programming problem. Part 2 took me a little too long
+  overall but it was fun.
+- Day 4: One of the easier grid based puzzles. Less than five minutes with
+  existing grid library.
+- Day 5: A problem with ranges; I decided to implement proper range merging this
+  time because I always kind of avoid that. I could probably decrease the
+  complexity from O(n^2) to O(n log(n)) but I am happy that I've implemented
+  merging at all.
+- Day 6: Transposing some rows and cols. Fun and good to keep the brain fit
+  but not really hard. I would have been way too slow for the leaderboard
+  in pre-AI years.
+- Day 7: Grid puzzle that required non-naiv implementation for part 2. Took
+  me a second to realize that I could not save the coordinates by list but
+  had to use a count to be efficient.
+- Day 8:
 
-- Day 1: 29:00 That was emberassingly slow. Out of my rhythm?
-- Day 2: 13:24 Getting back into it but still slow af, obviously.
-- Day 3: 11:20 Ugly and slow.
-- Day 4: 21:05 -__-
-- Day 5: 29:35 -___-
-- Day 6: 4:20 okay
-- Day 7: 31:20 hmm
-- Day 8: 14:50 meh
-- Day 9: 26:00 okay
-- Day 10: 23:07 okay
-- Day 11: 75:00 -__-
-- Day 12: 10:05 okay
-- Day 13: 9:43 okayish
-- Day 14: 120:00 struggled with this one (example incorrect?)
-- Day 15: Trial and error. Should use CRT instead.
-- Day 16: 14:11
-- Day 17: 45:00 didn't follow instructions... focus!
-- Day 18: 9:43
-- Day 19: 90:00 that wasn't easy for me
-- Day 20: 67:00
-- Day 21: 32:33
-- Day 22: 90:00
-- Day 23: 60:00
-- Day 24: 48:00
-- Day 25: 6:45
 
-## AoC 2017
+## AoC 2024
 
-- Day 1: 7:30
-- Day 2: 6:15
-- Day 3: 75:00 hmm should have been way quicker
-- Day 4: 3:02
-- Day 5: 6:13
-- Day 6: 8:37
-- Day 7: 19:22
-- Day 8: 8:15
-- Day 9: 6:10
-- Day 10: 55:00
-- Day 11: 66:06
-- Day 12: 6:44
-- Day 13: 120:00
-- Day 14: 17:48
-- Day 15: 11:40
-- Day 16: 13:16
-- Day 17: 55:00
-- Day 18: 23:00
-- Day 19: 45:00
-- Day 20: 9:55 (would have been 10th)
-- Day 21: 90:00
-- Day 22: 25:00
-- Day 23: Multiple days... but super fun.
-- Day 24: 15:45 (48th)
-- Day 25: 41:00
-
-## AoC 2018
-
-- Day 1: 1:49 (2nd)
-- Day 2: 10:53
-- Day 3: 6:16 (24th)
-- Day 4: 25:16
-- Day 5: 17:03
-- Day 6: 1:10:29
-- Day 7: 20:15
-- Day 8: 18:35
-- Day 9: 1:17:52
-- Day 10: 19:14
-- Day 11: 22:52
-- Day 12: 180:00
-- Day 13: 73:09
-- Day 14: 20:48
-- Day 15: 185:11
-- Day 16: 36:10
-- Day 17: 180:00
-- Day 18: 24:04
-- Day 19: days (super fun, but hard for me)
-- Day 20: weeks (a cache was all it took - weak)
-- Day 21: 28:40 (16th - brute force but still not so bad)
-- Day 22: 185:00 (should not have been so slow but was fun)
-- Day 23: days
-- Day 24: days
-- Day 25: 29:20 (slow)
-
-## AoC 2019
-
-- Day 1: 4:25   (copy and paste error, no leaderboard)
-- Day 2: 7:07   (19th)
-- Day 3: 10:46  (37th)
-- Day 4: 8:48   (just too slow, no leaderboard)
-- Day 5: 34:24  (that wasn't hard at all)
-- Day 6: 23:17  (so slow, no leaderboard)
-- Day 7: 72:17  (I found that one challenging, 30:33 would have been required for leaderboard)
-- Day 8: 08:55  (54th)
-- Day 9: 115:00 (Try to read next time.)
-- Day 10: 76:00 (This wasn't easy for me. Fun, though.)
-- Day 11: 21:04 (Too slow, but fun.)
-- Day 12: days  (Took me a while to get the right idea.)
-- Day 13: >120:00 (Just struggling so much for some reason.)
-- Day 14: >120:00 (Hmm, wasn't that hard either.)
-- Day 15: >120:00 (I am really weak at the moment.)
-- Day 16: days    (Wow. Just too hard for me to solve quickly?)
-- Day 17: days    (Fun but too tricky for me to be fast.)
-- Day 18: days    (Slow and slow algorithm.)
-- Day 19: 40:00   (Way too slow! Oversight error. Come on.)
-- Day 20: days    (Not actually that hard but I struggled for no reason.) 
-- Day 21: days    (But it was super fun!)
-- Day 22: days    (Needed some help...)
-- Day 23: 23:13   (Still too slow even though my int computer was in good shape...)
-- Day 24: 53:00   (Can I ever even get points at all?)
-- Day 25: 70:00   (Well, done at least. Super super fun!)
-
-## AoC 2020
-
-- Day 1: 2:48   (people weren't able to submit because of a website outage)
-- Day 2: 4:47   (no leaderboard, you can tell it's getting faster)
-- Day 3: 7:06   (way too slow, lol; time to take it seriously)
-- Day 4: 14:30  (yo, I am just too slow)
-- Day 5: 11:53  (not competitive)
-- Day 6: 4:11   (75th, finally on the leaderboard)
-- Day 7: 24:39  (bad)
-- Day 8: 6:26   (43th, tied George Hotz :)
-- Day 9: 7:37   (choked bad)
-- Day 10: 34:27 (so weak)
-- Day 11: 21:05 (hmmm, I rally have to analyze why I am so slow)
-- Day 12: 21:52 (just slow again for an easy problem)
-- Day 13: 18:00 (I don't really understand the CRT to be honest)
-- Day 14: 40:26 (Made a bunch of mistakes even misunderstanding Python)
-- Day 15: 17:57 (Too slow for an easy one like this)
-- Day 16: 33:00 (Not too unhappy really.)
-- Day 17: 10:00 (40th)
-- Day 18: 80:00 (I am struggling with stuff where parsing is involved)
-- Day 19: 78:00 (Should have been faster)
-- Day 20: 95:00 (Lot's of code)
-- Day 21: 23:02 (Simply to slow)
-- Day 22: 45:49 (Simple and too slow)
-- Day 23: 105:00 (Sad)
-- Day 24: 15:38 (Close to leaderboard)
-- Day 25: 14:40 (Way too slow)
-
-## AoC 2021
-
-- Day  1:   4:01   (Haha. Why am I so bad?!?!)
-- Day  2:   6:36   (Okay. I might as well stop doing these.)
-- Day  3:  23:46   (How long can I take when I try to take long?)
-- Day  4:  22:18   (No way. Such stupid bugs.)
-- Day  5:  13:30   (Decent, but obviously too slow.)
-- Day  6:  16:33   (Right idea quickly but then struggled to implement.)
-- Day  7:   6:12   (Decent, but too slow again, obviously. Maybe fast enough for part 1.)
-- Day  8:  72:00   (Yeah, that was too much of a struggle.)
-- Day  9:   8:07   (37th okay, okay)
-- Day 10:  15:50   (I was pretty happy with that but double the 100th place.)
-- Day 11:  11:43   (Could have been much faster here.)
-- Day 12:  19:11   (Okayish, but of course too slow for leaderboard.)
-- Day 13:  16:48   (Should have been way faster.)
-- Day 14:  25:52   (Not hard but just too slow.)
-- Day 15:  19:17   (Not that bad. Multiplying the thing threw me off.)
-- Day 16:  50:01   (Way too slow. Was non-trivial but fun. Much better was feasible.)
-- Day 17:  21:59   (Not tricky again but struggling for no reason.)
-- Day 18: 162:00   (I couldn't figure out how to solve it as a tree so I did the basic way.)
-- Day 19:   days   (Super hard for me but super fun ultimately once I had the right approach.)
-- Day 20: 105:00   (That wasn't easy but was able to solve in one go.)
-- Day 21:  37:45   (Wasn't hard but I was just too slow.)
-- Day 22: 142:00   (Wonderful problem and hard for me but learned something new for sure.)
-- Day 23:  81:38   (Fun but obviously not competitive.)
-- Day 24: 232:00   (Super hard for me but I am proud of it.)
-- Day 25:  15:43   (That could have been much much faster.)
-
-## AoC 2022
-
-Done with this. Overall everything is solvable. It's more about consistency
-and focus. Of course, learning more algorithms and techniques helps.
-
-**Times:**
-
-- Day  1: 7:52 ... so slow brah :/ top 100 required 2:05...
-- Day  2: 22:30 ... I mistyped the first and second was just bad top 100 would
-  have been 6:16 (doable?)
-- Day  3: 13:08 actually decent but top 100 required 5:24
-- Day  4: 7:08 but top 100 required 3:33 still okay
-- Day  5: 11:56 but 7:58 for top 100... getting better?
-- Day  6: 3:50 but 2:25 for leaderboard :D
-- Day  7: 27:55 and 14:47 for leaderboard; okay, I would say
-- Day  8: 61:00 and 10:00 for leaderboard; I need template code for searching
-  coordinate systems
-- Day  9: 58:00 and 7:32 for leaderboard; I need code for 2D stuff
-- Day 10: 25:20 and 12:17 for leaderboard; okay, okay
-- Day 11: 45:00 and 18:00 for leaderboard; arg, it was doable man
-- Day 12: 39:45 and 9:46 for leaderboard; the people are ready for their
-  searches :D
-- Day 13: 44:00 and 12:56 for leaderboard; these people are just good,
-  seriously
-- Day 14: 35:00 and 14:54; I just have to get that much quicker... 2D code!
-- Day 15: 150:00 and 27:00; I didn't use Manhattan dist initially, lot's of
-  debugging
-- Day 16: 52:00 and 64:00; ARE YOU SAYING I WOULD HAVE MADE THE
-  LEADERBOARD?!?!?!?!?!?!?!
-- Day 17: Second one was fun with having to detect the repetition.
-- Day 18: 12:00 and 32:00; really straightforward and of course way too slow.
-- Day 19: Slow. (2024-09-13 improved with help from hyper neutrino.)
-- Day 20: Struggled way too much.
-- Day 21: Straightforward and relatively fast.
-- Day 22: Very hard and wasn't able to do hands free. Even the best guys took
-  over an hour.
-- Day 23: Super straightforward, but took me way longer than it should have
-  because I loose focus and make silly errors. Like back in Middleschool.
-- Day 24: Easy. Should have been faster, but no crazy mistakes. Still way too
-  slow for something easy like this.
-- Day 25: Quickly solved via constraint solver. Actual solution much simpler. Don't know
-  if I would have been able to figure it out.
+- Day  1: `00:01:30   124      0   00:02:49    141      0`
+- Day  2: `00:05:34   686      0   00:08:21    531      0`
+- Day  3: `00:01:48   165      0   00:02:40     56     45`
+- Day  4: `00:07:47  1101      0   00:24:07   2410      0`
+- Day  5: `00:07:07   679      0   00:23:02   1998      0`
+- Day  6: `00:09:43  1082      0   00:16:29    464      0`
+- Day  7: `00:12:29  2058      0   00:13:08   1170      0`
+- Day  8: `00:15:59  1742      0   00:26:56   2190      0`
+- Day  9: `00:48:23  6055      0   01:09:38   3159      0`
+- Day 10: `00:19:47  2976      0   00:20:47   2244      0`
+- Day 11: `00:05:13   642      0   00:33:07   2673      0`
+- Day 12: `00:30:30  3540      0   11:41:33  16212      0`
+- Day 13: `00:05:35   225      0   00:55:48   2544      0`
+- Day 14: `00:20:41  2136      0   00:35:14   1048      0`
+- Day 15: `   >24h  32248      0       >24h  23671      0`
+- Day 16: `   >24h  24941      0       >24h  20575      0`
+- Day 17: `17:34:16 23722      0       >24h  17778      0`
+- Day 18: `14:35:01 20398      0   14:37:18  19550      0`
+- Day 19: `00:14:37  2001      0   00:19:43   1584      0`
+- Day 20: `01:08:53  3637      0   01:53:01   2837      0`
+- Day 21: `00:48:40   215      0       >24h  16427      0`
+- Day 22: `00:13:04  1930      0   00:28:29    739      0`
+- Day 23: `   >24h  20096      0       >24h  17620      0`
+- Day 24: `15:57:01 17307      0       >24h  11326      0`
+- Day 25: `10:41:54 14140      0       >24h  13631      0`
 
 
 ## AoC 2023
@@ -289,15 +105,249 @@ and focus. Of course, learning more algorithms and techniques helps.
   Manually plotting requires matplotlib and networkx packages.
 
 
-## AoC 2024
+## AoC 2022
 
-- Day 1: `00:01:30   124      0   00:02:49   141      0`
-- Day 2: `00:05:34   686      0   00:08:21   531      0`
-- Day 3: `00:01:48   165      0   00:02:40    56     45`
-- Day 4: `00:07:47  1101      0   00:24:07  2410      0`
-- Day 5: `00:07:07   679      0   00:23:02  1998      0`
-- Day 6: `00:09:43  1082      0   00:16:29   464      0`
-- Day 7: `00:12:29  2058      0   00:13:08  1170      0`
-- Day 8: `00:15:59  1742      0   00:26:56  2190      0`
-- Day 9: `00:48:23  6055      0   01:09:38  3159      0`
+Done with this. Overall everything is solvable. It's more about consistency
+and focus. Of course, learning more algorithms and techniques helps.
+
+**Times:**
+
+- Day  1: 7:52 ... so slow brah :/ top 100 required 2:05...
+- Day  2: 22:30 ... I mistyped the first and second was just bad top 100 would
+  have been 6:16 (doable?)
+- Day  3: 13:08 actually decent but top 100 required 5:24
+- Day  4: 7:08 but top 100 required 3:33 still okay
+- Day  5: 11:56 but 7:58 for top 100... getting better?
+- Day  6: 3:50 but 2:25 for leaderboard :D
+- Day  7: 27:55 and 14:47 for leaderboard; okay, I would say
+- Day  8: 61:00 and 10:00 for leaderboard; I need template code for searching
+  coordinate systems
+- Day  9: 58:00 and 7:32 for leaderboard; I need code for 2D stuff
+- Day 10: 25:20 and 12:17 for leaderboard; okay, okay
+- Day 11: 45:00 and 18:00 for leaderboard; arg, it was doable man
+- Day 12: 39:45 and 9:46 for leaderboard; the people are ready for their
+  searches :D
+- Day 13: 44:00 and 12:56 for leaderboard; these people are just good,
+  seriously
+- Day 14: 35:00 and 14:54; I just have to get that much quicker... 2D code!
+- Day 15: 150:00 and 27:00; I didn't use Manhattan dist initially, lot's of
+  debugging
+- Day 16: 52:00 and 64:00; ARE YOU SAYING I WOULD HAVE MADE THE
+  LEADERBOARD?!?!?!?!?!?!?!
+- Day 17: Second one was fun with having to detect the repetition.
+- Day 18: 12:00 and 32:00; really straightforward and of course way too slow.
+- Day 19: Slow. (2024-09-13 improved with help from hyper neutrino.)
+- Day 20: Struggled way too much.
+- Day 21: Straightforward and relatively fast.
+- Day 22: Very hard and wasn't able to do hands free. Even the best guys took
+  over an hour.
+- Day 23: Super straightforward, but took me way longer than it should have
+  because I loose focus and make silly errors. Like back in Middleschool.
+- Day 24: Easy. Should have been faster, but no crazy mistakes. Still way too
+  slow for something easy like this.
+- Day 25: Quickly solved via constraint solver. Actual solution much simpler. Don't know
+  if I would have been able to figure it out.
+
+
+## AoC 2021
+
+- Day  1:   4:01   (Haha. Why am I so bad?!?!)
+- Day  2:   6:36   (Okay. I might as well stop doing these.)
+- Day  3:  23:46   (How long can I take when I try to take long?)
+- Day  4:  22:18   (No way. Such stupid bugs.)
+- Day  5:  13:30   (Decent, but obviously too slow.)
+- Day  6:  16:33   (Right idea quickly but then struggled to implement.)
+- Day  7:   6:12   (Decent, but too slow again, obviously. Maybe fast enough for part 1.)
+- Day  8:  72:00   (Yeah, that was too much of a struggle.)
+- Day  9:   8:07   (37th okay, okay)
+- Day 10:  15:50   (I was pretty happy with that but double the 100th place.)
+- Day 11:  11:43   (Could have been much faster here.)
+- Day 12:  19:11   (Okayish, but of course too slow for leaderboard.)
+- Day 13:  16:48   (Should have been way faster.)
+- Day 14:  25:52   (Not hard but just too slow.)
+- Day 15:  19:17   (Not that bad. Multiplying the thing threw me off.)
+- Day 16:  50:01   (Way too slow. Was non-trivial but fun. Much better was feasible.)
+- Day 17:  21:59   (Not tricky again but struggling for no reason.)
+- Day 18: 162:00   (I couldn't figure out how to solve it as a tree so I did the basic way.)
+- Day 19:   days   (Super hard for me but super fun ultimately once I had the right approach.)
+- Day 20: 105:00   (That wasn't easy but was able to solve in one go.)
+- Day 21:  37:45   (Wasn't hard but I was just too slow.)
+- Day 22: 142:00   (Wonderful problem and hard for me but learned something new for sure.)
+- Day 23:  81:38   (Fun but obviously not competitive.)
+- Day 24: 232:00   (Super hard for me but I am proud of it.)
+- Day 25:  15:43   (That could have been much much faster.)
+
+
+## AoC 2020
+
+- Day 1: 2:48   (people weren't able to submit because of a website outage)
+- Day 2: 4:47   (no leaderboard, you can tell it's getting faster)
+- Day 3: 7:06   (way too slow, lol; time to take it seriously)
+- Day 4: 14:30  (yo, I am just too slow)
+- Day 5: 11:53  (not competitive)
+- Day 6: 4:11   (75th, finally on the leaderboard)
+- Day 7: 24:39  (bad)
+- Day 8: 6:26   (43th, tied George Hotz :)
+- Day 9: 7:37   (choked bad)
+- Day 10: 34:27 (so weak)
+- Day 11: 21:05 (hmmm, I rally have to analyze why I am so slow)
+- Day 12: 21:52 (just slow again for an easy problem)
+- Day 13: 18:00 (I don't really understand the CRT to be honest)
+- Day 14: 40:26 (Made a bunch of mistakes even misunderstanding Python)
+- Day 15: 17:57 (Too slow for an easy one like this)
+- Day 16: 33:00 (Not too unhappy really.)
+- Day 17: 10:00 (40th)
+- Day 18: 80:00 (I am struggling with stuff where parsing is involved)
+- Day 19: 78:00 (Should have been faster)
+- Day 20: 95:00 (Lot's of code)
+- Day 21: 23:02 (Simply to slow)
+- Day 22: 45:49 (Simple and too slow)
+- Day 23: 105:00 (Sad)
+- Day 24: 15:38 (Close to leaderboard)
+- Day 25: 14:40 (Way too slow)
+
+
+## AoC 2019
+
+- Day 1: 4:25   (copy and paste error, no leaderboard)
+- Day 2: 7:07   (19th)
+- Day 3: 10:46  (37th)
+- Day 4: 8:48   (just too slow, no leaderboard)
+- Day 5: 34:24  (that wasn't hard at all)
+- Day 6: 23:17  (so slow, no leaderboard)
+- Day 7: 72:17  (I found that one challenging, 30:33 would have been required for leaderboard)
+- Day 8: 08:55  (54th)
+- Day 9: 115:00 (Try to read next time.)
+- Day 10: 76:00 (This wasn't easy for me. Fun, though.)
+- Day 11: 21:04 (Too slow, but fun.)
+- Day 12: days  (Took me a while to get the right idea.)
+- Day 13: >120:00 (Just struggling so much for some reason.)
+- Day 14: >120:00 (Hmm, wasn't that hard either.)
+- Day 15: >120:00 (I am really weak at the moment.)
+- Day 16: days    (Wow. Just too hard for me to solve quickly?)
+- Day 17: days    (Fun but too tricky for me to be fast.)
+- Day 18: days    (Slow and slow algorithm.)
+- Day 19: 40:00   (Way too slow! Oversight error. Come on.)
+- Day 20: days    (Not actually that hard but I struggled for no reason.) 
+- Day 21: days    (But it was super fun!)
+- Day 22: days    (Needed some help...)
+- Day 23: 23:13   (Still too slow even though my int computer was in good shape...)
+- Day 24: 53:00   (Can I ever even get points at all?)
+- Day 25: 70:00   (Well, done at least. Super super fun!)
+
+
+## AoC 2018
+
+- Day 1: 1:49 (2nd)
+- Day 2: 10:53
+- Day 3: 6:16 (24th)
+- Day 4: 25:16
+- Day 5: 17:03
+- Day 6: 1:10:29
+- Day 7: 20:15
+- Day 8: 18:35
+- Day 9: 1:17:52
+- Day 10: 19:14
+- Day 11: 22:52
+- Day 12: 180:00
+- Day 13: 73:09
+- Day 14: 20:48
+- Day 15: 185:11
+- Day 16: 36:10
+- Day 17: 180:00
+- Day 18: 24:04
+- Day 19: days (super fun, but hard for me)
+- Day 20: weeks (a cache was all it took - weak)
+- Day 21: 28:40 (16th - brute force but still not so bad)
+- Day 22: 185:00 (should not have been so slow but was fun)
+- Day 23: days
+- Day 24: days
+- Day 25: 29:20 (slow)
+
+
+## AoC 2017
+
+- Day 1: 7:30
+- Day 2: 6:15
+- Day 3: 75:00 hmm should have been way quicker
+- Day 4: 3:02
+- Day 5: 6:13
+- Day 6: 8:37
+- Day 7: 19:22
+- Day 8: 8:15
+- Day 9: 6:10
+- Day 10: 55:00
+- Day 11: 66:06
+- Day 12: 6:44
+- Day 13: 120:00
+- Day 14: 17:48
+- Day 15: 11:40
+- Day 16: 13:16
+- Day 17: 55:00
+- Day 18: 23:00
+- Day 19: 45:00
+- Day 20: 9:55 (would have been 10th)
+- Day 21: 90:00
+- Day 22: 25:00
+- Day 23: Multiple days... but super fun.
+- Day 24: 15:45 (48th)
+- Day 25: 41:00
+
+
+## AoC 2016
+
+- Day 1: 29:00 That was emberassingly slow. Out of my rhythm?
+- Day 2: 13:24 Getting back into it but still slow af, obviously.
+- Day 3: 11:20 Ugly and slow.
+- Day 4: 21:05 -__-
+- Day 5: 29:35 -___-
+- Day 6: 4:20 okay
+- Day 7: 31:20 hmm
+- Day 8: 14:50 meh
+- Day 9: 26:00 okay
+- Day 10: 23:07 okay
+- Day 11: 75:00 -__-
+- Day 12: 10:05 okay
+- Day 13: 9:43 okayish
+- Day 14: 120:00 struggled with this one (example incorrect?)
+- Day 15: Trial and error. Should use CRT instead.
+- Day 16: 14:11
+- Day 17: 45:00 didn't follow instructions... focus!
+- Day 18: 9:43
+- Day 19: 90:00 that wasn't easy for me
+- Day 20: 67:00
+- Day 21: 32:33
+- Day 22: 90:00
+- Day 23: 60:00
+- Day 24: 48:00
+- Day 25: 6:45
+
+
+## AoC 2015
+
+- Day 1: 3:10
+- Day 2: 5:24 :/ 
+- Day 3: 7:26 ... :/
+- Day 4: 5:11 ...
+- Day 5: 14:05 o.O
+- Day 6: 15:00
+- Day 7: 17:00
+- Day 8: 14:55
+- Day 9: 13:48
+- Day 10: 70:00 ... slow, but fun
+- Day 11: 12:30
+- Day 12: 6:03
+- Day 13: 7:06 (would have been first by a minute, probably 70ish in 2023)
+- Day 14: 27:45 ... that was weak, logic error for part 2 :/
+- Day 15: 16:00 I should probably stop brute forcing these optimization problems
+- Day 16: 19:00
+- Day 17: 9:05
+- Day 18: 10:39
+- Day 19: Many days... yeah this one took me way too long to figure out
+- Day 20: 10:54
+- Day 21: 25:52 cute bug where I didn't consider that no armor is an option
+- Day 22: That was bad. Did not know how to choose between dfs/bfs and logic errors.
+- Day 23: 10:00
+- Day 24: 20:00 ugly - recursive solution would be more elegant
+- Day 25: 9:34
 

lib.py

@@ -276,7 +276,7 @@ def extract_year_and_date(scriptname) -> tuple[str, str]:
 def get_data(filename):
     path, file = os.path.split(filename)
     year = path[-4:]
-    day = file.replace("d", "").replace(".py", "")
+    day = file.replace("d0", "").replace("d", "").replace(".py", "")
     txt_file = f"d{day}.txt"
 
     if os.path.isfile(txt_file):

pyproject.toml

@@ -0,0 +1,10 @@
+[project]
+name = "aocpy"
+version = "0.1.0"
+description = "Make ruff and ty available via uv"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "ruff>=0.14.11",
+    "ty>=0.0.11",
+]