Add utils

Author: SH1RL0CK

.gitignore

@@ -1 +1,2 @@
-.venv
+.venv
+__pycache__

.vscode/launch.json

@@ -5,12 +5,50 @@
     "version": "0.2.0",
     "configurations": [
         {
-            "name": "Python: Current File",
-            "type": "python",
+            "name": "Part A Example",
+            "type": "debugpy",
             "request": "launch",
             "program": "${file}",
             "console": "internalConsole",
-            "justMyCode": true
+            "env": {
+                "MODE": "part_a_example",
+                "PYTHONPATH": "${workspaceFolder}:${env:PYTHONPATH}"
+            }
+        },
+        {
+            "name": "Part A",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "internalConsole",
+            "justMyCode": true,
+            "env": {
+                "MODE": "part_a",
+                "PYTHONPATH": "${workspaceFolder}:${env:PYTHONPATH}"
+            }
+        },
+        {
+            "name": "Part B Example",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "internalConsole",
+            "justMyCode": true,
+            "env": {
+                "MODE": "part_b_example",
+                "PYTHONPATH": "${workspaceFolder}:${env:PYTHONPATH}"
+            }
+        },
+        {
+            "name": "Part B",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "internalConsole",
+            "env": {
+                "MODE": "part_b",
+                "PYTHONPATH": "${workspaceFolder}:${env:PYTHONPATH}"
+            }
         }
     ]
 }

.vscode/python.code-snippets

@@ -3,6 +3,7 @@
         "prefix": "aoc",
         "body": [
             "from aocd.models import Puzzle",
+            "import os",
             "",
             "puzzle = Puzzle(year=2024, day=${1:day})",
             "input_data = puzzle.input_data.splitlines()",
@@ -18,12 +19,23 @@
             "",
             "",
             "if __name__ == '__main__':",
-            "    answer_a = part_a(example_input_data)",
-            "    print(f\"Answer A: {answer_a}\")",
-            "    # puzzle.answer_a = answer_a",
-            "    # answer_b = part_b(example_input_data)",
-            "    # print(f\"Answer B: {answer_b}\")",
-            "    # puzzle.answer_b = answer_b"
+            "    match os.environ.get('MODE'):",
+            "        case 'part_a_example':",
+            "            answer_a = part_a(example_input_data)",
+            "            print(f\"Answer A: {answer_a}\")",
+            "        case 'part_a':",
+            "            answer_a = part_a(input_data)",
+            "            print(f\"Answer A: {answer_a}\")",
+            "            puzzle.answer_a = answer_a",
+            "        case 'part_b_example':",
+            "            answer_b = part_b(example_input_data)",
+            "            print(f\"Answer B: {answer_b}\")",
+            "        case 'part_b':",
+            "            answer_b = part_b(input_data)",
+            "            print(f\"Answer B: {answer_b}\")",
+            "            puzzle.answer_b = answer_b",
+            "        case _:",
+            "            print('No MODE set')",
         ],
         "description": "Advent of code 2023",
         "isFileTemplate": true

.vscode/settings.json

@@ -1,4 +1,4 @@
 {
-    "vscodeGitCommit.template": ["add solution for 2023/"],
+    "vscodeGitCommit.template": ["add solution for 2024/"],
     "vscodeGitCommit.insertMode": "Concatenate"
 }

README.md

@@ -1,2 +1,7 @@
 # Advent of Code
-These are my solutions of the [Advent of Code](https://adventofcode.com/) puzzles.
+
+These are my solutions of the [Advent of Code](https://adventofcode.com/) puzzles.
+
+## Credits
+
+Thanks to [Defelo](https://github.com/Defelo) for the utils functions from his [AoC repo](https://github.com/Defelo/AdventOfCode).

utils/__init__.py

@@ -0,0 +1,5 @@
+from .graph import *
+from .grid import *
+from .lists import *
+from .math_utils import *
+from .parsing import *

utils/graph.py

@@ -0,0 +1,25 @@
+class UnionFind:
+    def __init__(self, n):
+        self.parents = [*range(n)]
+
+    def find(self, x):
+        if self.parents[x] == x:
+            return x
+        self.parents[x] = self.find(self.parents[x])
+        return self.parents[x]
+
+    def merge(self, x, y):
+        self.parents[self.find(x)] = self.find(y)
+
+    def connected(self, x, y):
+        return self.find(x) == self.find(y)
+
+    def count(self):
+        return len(set(map(self.find, range(len(self.parents)))))
+
+    def components(self):
+        out = {}
+        for parent, i in zip(map(self.find, range(len(self.parents))), range(len(self.parents))):
+            out.setdefault(parent, []).append(i)
+
+        return out

utils/grid.py

@@ -0,0 +1,62 @@
+NEIGH_DICT = {
+    "N": (0, -1),
+    "E": (1, 0),
+    "S": (0, 1),
+    "W": (-1, 0),
+    "U": (0, -1),
+    "D": (0, 1),
+    "L": (-1, 0),
+    "R": (1, 0),
+}
+
+NEIGH_DIRECT = [*{*NEIGH_DICT.values()}]
+NEIGH_DIAG = [tuple(NEIGH_DICT[a][i] + NEIGH_DICT[b][i] for i in range(2)) for a, b in zip("NESW", "ESWN")]
+
+
+def get_neighbors(ox=0, oy=0, w=None, h=None, diag=False, include_self=False):
+    return [
+        (x, y)
+        for dx, dy in NEIGH_DIRECT + (NEIGH_DIAG * diag) + ([(0, 0)] * include_self)
+        if ((x := ox + dx) or 1)
+        and (w is None or x in range(w))
+        and ((y := oy + dy) or 1)
+        and (h is None or y in range(h))
+    ]
+
+
+def rotate_left(x, y):
+    return y, -x
+
+
+def rotate_right(x, y):
+    return -y, x
+
+
+def rotate_matrix_left(matrix):
+    return [*zip(*matrix)][::-1]
+
+
+def rotate_matrix_right(matrix):
+    return [*zip(*matrix[::-1])]
+
+
+def iter_line(x1, y1, x2, y2):
+    xr = range(min(x1, x2), max(x1, x2) + 1)
+    if x1 > x2:
+        xr = xr[::-1]
+
+    yr = range(min(y1, y2), max(y1, y2) + 1)
+    if y1 > y2:
+        yr = yr[::-1]
+
+    if x1 == x2:
+        xr = [x1] * len(yr)
+    if y1 == y2:
+        yr = [y1] * len(xr)
+
+    for x, y in zip(xr, yr):
+        yield x, y
+
+
+def transpose(matrix):
+    return [*zip(*matrix)]

utils/lists.py

@@ -0,0 +1,26 @@
+def most_common(lst, values=None):
+    return max(values or set(lst), key=lst.count)
+
+
+def least_common(lst, values=None):
+    return min(values or set(lst), key=lst.count)
+
+
+def minmax(lst, key=None):
+    return min(lst, key=key), max(lst, key=key)
+
+
+def irange(start=0, step=1):
+    i = start
+    while True:
+        yield i
+        i += step
+
+
+def sliding_window(seq, n=2):
+    lst = []
+    for elem in seq:
+        lst.append(elem)
+        if len(lst) == n:
+            yield tuple(lst)
+            lst.pop(0)

utils/math_utils.py

@@ -0,0 +1,35 @@
+from functools import reduce
+import operator
+
+
+def product(it):
+    return reduce(operator.mul, it)
+
+
+def extended_gcd(a, b):
+    if a == 0:
+        return b, 0, 1
+
+    gcd, x1, y1 = extended_gcd(b % a, a)
+
+    x = y1 - (b // a) * x1
+    y = x1
+
+    return gcd, x, y
+
+
+def chinese_remainder(n, a):
+    s = 0
+    prod = reduce(int.__mul__, n)
+    for n_i, a_i in zip(n, a):
+        p = prod // n_i
+        s += a_i * extended_gcd(p, n_i)[1] * p
+    return s % prod
+
+
+def is_prime(n):
+    if n < 5:
+        return n in [2, 3]
+    if n % 6 not in [1, 5]:
+        return False
+    return all(n % i for i in range(2, int(n**0.5) + 1))

utils/parsing.py

@@ -0,0 +1,50 @@
+import re
+
+
+def ints(inp):
+    return [int(x[0]) for x in re.finditer(r"[+-]?\d+", inp)]
+
+
+def pints(inp):
+    return [int(x[0]) for x in re.finditer(r"\d+", inp)]
+
+
+def floats(inp):
+    return [float(x[0]) for x in re.finditer(r"[+-]?(\d*\.)?\d+", inp)]
+
+
+def pfloats(inp):
+    return [float(x[0]) for x in re.finditer(r"(\d*\.)?\d+", inp)]
+
+
+def parse_ascii(dots: set[tuple[int, int]]) -> str:
+    out = ""
+    n = 0
+    while True:
+        k = 0
+        for j in range(5 * n, 5 * n + 4):
+            for i in range(6):
+                k <<= 1
+                k |= (i, j) in dots
+        if not k:
+            break
+        out += {
+            0b011111100100100100011111: "A",
+            0b111111101001101001010110: "B",
+            0b011110100001100001010010: "C",
+            0b111111101001101001100001: "E",
+            0b111111101000101000100000: "F",
+            0b011110100001100101010111: "G",
+            0b111111001000001000111111: "H",
+            0b000010000001100001111111: "J",
+            0b000010000001100001111110: "J",
+            0b111111001000010110100001: "K",
+            0b111111000001000001000001: "L",
+            0b111111100100100100011000: "P",
+            0b111111100100100110011001: "R",
+            0b111110000001000001111110: "U",
+            0b100011100101101001110001: "Z",
+        }.get(k, "?")
+        n += 1
+
+    return out