Initiate multi-year advent-of-code setup

Author: andredelft

.gitignore

@@ -0,0 +1,2 @@
+*.egg-info
+input.txt

cli.py

@@ -0,0 +1,159 @@
+import click
+from datetime import datetime
+from aocd import get_data, submit as aocd_submit
+from pathlib import Path
+import yaml
+from importlib import import_module
+import sys
+from string import Template
+
+sys.path.append(str(Path.cwd()))
+
+
+TODAY = datetime.now().day
+CURRENT_YEAR = datetime.now().year
+
+ENTRYPOINTS_FILE = Path("entrypoints.yaml")
+SOLUTION_TEMPLATE_FILE = Path("templates", "solution.template.py")
+TEST_TEMPLATE_FILE = Path("templates", "test.template.py")
+
+with open(ENTRYPOINTS_FILE) as f:
+    ENTRYPOINTS = yaml.safe_load(f) or {}
+
+with open(SOLUTION_TEMPLATE_FILE) as f:
+    SOLUTION_TEMPLATE = f.read()
+
+with open(TEST_TEMPLATE_FILE) as f:
+    TEST_TEMPLATE = f.read()
+
+
+def get_templates():
+    return SOLUTION_TEMPLATE, Template(TEST_TEMPLATE)
+
+
+def update_entrypoints():
+    with open(ENTRYPOINTS_FILE, "w") as f:
+        yaml.safe_dump(ENTRYPOINTS, f)
+
+
+def get_day_path(year: int, day: int):
+    return Path(f"y{year}", f"d{day:02d}")
+
+
+def get_day_module(year: int, day: int, module_name: str, test=False):
+    return f"y{year}.d{day:02d}.{'test_' if test else ''}{module_name}"
+
+
+def get_module(year: int, day: int, test=False):
+    module_name = ENTRYPOINTS.get(year, {}).get(day)
+
+    if not module_name:
+        click.BadParameter(f"Year {year} day {day} is not initialized yet")
+
+    module = get_day_module(year, day, module_name, test)
+
+    return import_module(module)
+
+
+def get_solution(year: int, day: int, part: int):
+    m = get_module(year, day)
+    solve_fn = getattr(m, f"part_{part}")
+
+    input_path = get_day_path(year, day) / "input.txt"
+
+    if not input_path.is_file():
+        input_string = get_data(year=year, day=day)
+
+        with open(input_path, "w") as f:
+            f.write(input_string)
+    else:
+        with open(input_path) as f:
+            input_string = f.read()
+
+    return solve_fn(input_string)
+
+
+def find_puzzle(selector: list[str]):
+    year = CURRENT_YEAR
+    day = TODAY
+    part = "a"
+
+    match len(selector):
+        case 3:
+            year, day, part = selector
+        case 2:
+            if selector[1] in ["a", "b"]:
+                day, part = selector
+            else:
+                year, day = selector
+        case 1:
+            day = selector[0]
+
+    return int(year), int(day), part
+
+
+def test_solution(year: int, day: int, part: int):
+    m = get_module(year, day, test=True)
+
+    test_input = m.TEST_INPUT
+    solve_fn = getattr(m, f"part_{part}")
+
+    click.echo(solve_fn(test_input))
+
+
+arg_module_name = click.argument("module_name")
+arg_selector = click.argument("selector", nargs=-1)
+
+
+@click.command()
+@arg_module_name
+@arg_selector
+def prepare(module_name, selector):
+    year, day, _ = find_puzzle(selector)
+
+    input_data = get_data(year=year, day=day)
+    solution_template, test_template = get_templates()
+
+    puzzle_path = get_day_path(year, day)
+    puzzle_path.mkdir(parents=True, exist_ok=True)
+
+    with open(puzzle_path / "input.txt", "w") as f:
+        f.write(input_data)
+
+    with open(puzzle_path / f"{module_name}.py", "w") as f:
+        f.write(solution_template)
+
+    with open(puzzle_path / f"test_{module_name}.py", "w") as f:
+        f.write(test_template.substitute(module=get_day_module(year, day, module_name)))
+
+    ENTRYPOINTS[year] = ENTRYPOINTS.get(year, {})
+    ENTRYPOINTS[year][day] = module_name
+    update_entrypoints()
+
+
+@click.command()
+@arg_selector
+def test(selector):
+    year, day, part = find_puzzle(selector)
+    test_solution(year, day, part)
+
+
+@click.command()
+@arg_selector
+def solve(selector):
+    year, day, part = find_puzzle(selector)
+
+    click.echo(get_solution(year, day, part))
+
+
+@click.command()
+@arg_selector
+def submit(selector):
+    year, day, part = find_puzzle(selector)
+
+    solution = get_solution(year, day, part)
+
+    if not solution:
+        raise click.ClickException("Nothing to submit")
+
+    aocd_submit(solution, year=year, day=day, part=part)

entrypoints.yaml

@@ -0,0 +1,39 @@
+2019:
+  1: rocket_equation
+  2: program_alarm
+  3: crossed_wires
+  4: secure_container
+2022:
+  1: calorie_counting
+  2: rock_paper_scissors
+  3: rucksack_reorganization
+  4: camp_cleanup
+  5: supply_stacks
+  6: tuning_trouble
+  7: no_space
+  8: treetop_tree_house
+  9: rope_bridge
+  10: cathode_ray_tube
+  11: monkey_in_the_middle
+  12: hill_climbing
+  13: distress_signal
+  14: regolith_reservoir
+2023:
+  1: trebuchet
+  2: cube_conundrum
+  3: gear_ratios
+  4: scratchcards
+  5: fertilizer
+  6: wait_for_it
+  7: camel_cards
+  8: haunted_wasteland
+  9: mirage_maintainance
+  10: pipe_maze
+  11: cosmic_expansion
+  12: hot_springs
+  13: point_of_incidence
+  14: parabolic_reflector_dish
+  15: lens_library
+  16: lava_floor
+  17: clumsy_crubicle
+  18: lavaduct_lagoon

lib/array.py

@@ -0,0 +1,44 @@
+from bisect import bisect_left, insort
+
+
+def split_list(obj: list, index: int) -> tuple[list, list]:
+    """Splits list into two at given index."""
+    return obj[:index], obj[index:]
+
+
+def product(obj: list[int]):
+    prod = 1
+
+    for item in obj:
+        prod *= item
+
+    return prod
+
+
+class SortedList(object):
+    def __init__(self, lst, key=None):
+        self._lst = sorted(lst, key=key)
+        self._key = key
+
+    def __str__(self):
+        return str(self._lst)
+
+    def __repr__(self):
+        return f"<SortedList {repr(self._lst)}>"
+
+    def pop(self, index):
+        return self._lst.pop(index)
+
+    def add(self, item):
+        insort(self._lst, item, key=self._key)
+
+    def find(self, item):
+        lookup_value = self._key(item) if self._key else item
+        index = bisect_left(self._lst, lookup_value, key=self._key)
+
+        while self._lst[index] != item:
+            index += 1
+            if self._key(item) != lookup_value:
+                return -1
+
+        return index

lib/dijkstra.py

@@ -0,0 +1,93 @@
+from functools import total_ordering
+from typing import TypeVar
+from tqdm import tqdm
+
+from lib.array import SortedList
+
+Node = TypeVar("Node")
+
+
+@total_ordering
+class DistanceEntry(object):
+    def __init__(self, distance: int, prev_node: Node):
+        self.distance = distance
+        self.prev_node = prev_node
+
+    def __eq__(self, other):
+        return self.prev_node == other.prev_node and self.distance == other.distance
+
+    def __lt__(self, other):
+        return self.distance < other.distance
+
+    def __repr__(self):
+        return f"({repr(self.prev_node)}, {repr(self.distance)})"
+
+
+class DistanceMap(object):
+    def __init__(self, start_node: Node):
+        self.distance_map = {start_node: DistanceEntry(0, None)}
+
+    def get_distance(self, node):
+        distance_entry = self.distance_map.get(node)
+
+        if not distance_entry:
+            raise KeyError("No record exist of this node")
+
+        return distance_entry.distance
+
+    def nodes(self):
+        return self.distance_map.keys()
+
+    def add(self, node_from: Node, node_to: Node, distance: int):
+        self.distance_map[node_to] = DistanceEntry(distance, node_from)
+
+    def backtrace_path(self, node):
+        current_node = node
+        while current_node != None:
+            yield current_node
+            current_node = self.distance_map[current_node].prev_node
+
+
+class NoPossiblePath(Exception):
+    pass
+
+
+def dijkstra(start_node: Node, end_node, get_neighbours, total_nodes: int = None):
+    distance_map = DistanceMap(start_node)
+    visited = {start_node}
+    unvisited = SortedList([start_node], key=distance_map.get_distance)
+
+    is_end_node = (
+        lambda node: end_node(node) if callable(end_node) else end_node == node
+    )
+
+    current_node = start_node
+    with tqdm(total=total_nodes, desc="Performing Dijkstra's algorithm") as pbar:
+        while not is_end_node(current_node):
+            try:
+                current_node = unvisited.pop(0)
+            except IndexError:
+                raise NoPossiblePath("No path possible between start and end node")
+
+            for neighbour, distance in get_neighbours(current_node):
+                current_distance = distance_map.get_distance(current_node) + distance
+
+                if neighbour in distance_map.nodes():
+                    existing_distance = distance_map.get_distance(neighbour)
+
+                    if existing_distance > current_distance:
+                        neighbour_index = unvisited.find(neighbour)
+                        unvisited.pop(neighbour_index)
+                    else:
+                        continue
+
+                distance_map.add(current_node, neighbour, current_distance)
+                unvisited.add(neighbour)
+
+            visited.add(current_node)
+            pbar.update()
+
+    if callable(end_node):
+        return distance_map, current_node
+
+    return distance_map