Day 20 Part 1

Author: monpie3

Day_20/README.md

@@ -0,0 +1,137 @@
+## \--- Day 20: Race Condition ---
+
+The Historians are quite pixelated again. This time, a massive, black building looms over you - you're [right outside](https://adventofcode.com/2017/day/24) the CPU!
+
+While The Historians get to work, a nearby program sees that you're idle and challenges you to a _race_. Apparently, you've arrived just in time for the frequently-held _race condition_ festival!
+
+The race takes place on a particularly long and twisting code path; programs compete to see who can finish in the _fewest picoseconds_. The winner even gets their very own [mutex](https://en.wikipedia.org/wiki/Lock_\(computer_science\))!
+
+They hand you a _map of the racetrack_ (your puzzle input). For example:
+
+```
+###############
+#...#...#.....#
+#.#.#.#.#.###.#
+#S#...#.#.#...#
+#######.#.#.###
+#######.#.#...#
+#######.#.###.#
+###..E#...#...#
+###.#######.###
+#...###...#...#
+#.#####.#.###.#
+#.#...#.#.#...#
+#.#.#.#.#.#.###
+#...#...#...###
+###############
+```
+
+The map consists of track (`.`) - including the _start_ (`S`) and _end_ (`E`) positions (both of which also count as track) - and _walls_ (`#`).
+
+When a program runs through the racetrack, it starts at the start position. Then, it is allowed to move up, down, left, or right; each such move takes _1 picosecond_. The goal is to reach the end position as quickly as possible. In this example racetrack, the fastest time is `84` picoseconds.
+
+Because there is only a single path from the start to the end and the programs all go the same speed, the races used to be pretty boring. To make things more interesting, they introduced a new rule to the races: programs are allowed to _cheat_.
+
+The rules for cheating are very strict. _Exactly once_ during a race, a program may _disable collision_ for up to _2 picoseconds_. This allows the program to _pass through walls_ as if they were regular track. At the end of the cheat, the program must be back on normal track again; otherwise, it will receive a [segmentation fault](https://en.wikipedia.org/wiki/Segmentation_fault) and get disqualified.
+
+So, a program could complete the course in 72 picoseconds (saving _12 picoseconds_) by cheating for the two moves marked `1` and `2`:
+
+```
+###############
+#...#...12....#
+#.#.#.#.#.###.#
+#S#...#.#.#...#
+#######.#.#.###
+#######.#.#...#
+#######.#.###.#
+###..E#...#...#
+###.#######.###
+#...###...#...#
+#.#####.#.###.#
+#.#...#.#.#...#
+#.#.#.#.#.#.###
+#...#...#...###
+###############
+```
+
+Or, a program could complete the course in 64 picoseconds (saving _20 picoseconds_) by cheating for the two moves marked `1` and `2`:
+
+```
+###############
+#...#...#.....#
+#.#.#.#.#.###.#
+#S#...#.#.#...#
+#######.#.#.###
+#######.#.#...#
+#######.#.###.#
+###..E#...12..#
+###.#######.###
+#...###...#...#
+#.#####.#.###.#
+#.#...#.#.#...#
+#.#.#.#.#.#.###
+#...#...#...###
+###############
+```
+
+This cheat saves _38 picoseconds_:
+
+```
+###############
+#...#...#.....#
+#.#.#.#.#.###.#
+#S#...#.#.#...#
+#######.#.#.###
+#######.#.#...#
+#######.#.###.#
+###..E#...#...#
+###.####1##.###
+#...###.2.#...#
+#.#####.#.###.#
+#.#...#.#.#...#
+#.#.#.#.#.#.###
+#...#...#...###
+###############
+```
+
+This cheat saves _64 picoseconds_ and takes the program directly to the end:
+
+```
+###############
+#...#...#.....#
+#.#.#.#.#.###.#
+#S#...#.#.#...#
+#######.#.#.###
+#######.#.#...#
+#######.#.###.#
+###..21...#...#
+###.#######.###
+#...###...#...#
+#.#####.#.###.#
+#.#...#.#.#...#
+#.#.#.#.#.#.###
+#...#...#...###
+###############
+```
+
+Each cheat has a distinct _start position_ (the position where the cheat is activated, just before the first move that is allowed to go through walls) and _end position_; cheats are uniquely identified by their start position and end position.
+
+In this example, the total number of cheats (grouped by the amount of time they save) are as follows:
+
+- There are 14 cheats that save 2 picoseconds.
+- There are 14 cheats that save 4 picoseconds.
+- There are 2 cheats that save 6 picoseconds.
+- There are 4 cheats that save 8 picoseconds.
+- There are 2 cheats that save 10 picoseconds.
+- There are 3 cheats that save 12 picoseconds.
+- There is one cheat that saves 20 picoseconds.
+- There is one cheat that saves 36 picoseconds.
+- There is one cheat that saves 38 picoseconds.
+- There is one cheat that saves 40 picoseconds.
+- There is one cheat that saves 64 picoseconds.
+
+You aren't sure what the conditions of the racetrack will be like, so to give yourself as many options as possible, you'll need a list of the best cheats. _How many cheats would save you at least 100 picoseconds?_
+
+Your puzzle answer was `[REDACTED]`.
+
+The first half of this puzzle is complete! It provides one gold star: ⭐

Day_20/example_20a.txt

@@ -0,0 +1,15 @@
+###############
+#...#...#.....#
+#.#.#.#.#.###.#
+#S#...#.#.#...#
+#######.#.#.###
+#######.#.#...#
+#######.#.###.#
+###..E#...#...#
+###.#######.###
+#...###...#...#
+#.#####.#.###.#
+#.#...#.#.#...#
+#.#.#.#.#.#.###
+#...#...#...###
+###############

Day_20/task_20a.py

@@ -0,0 +1,89 @@
+import collections
+
+
+def load_map(filename):
+    with open(filename, "r") as f:
+        map_data = f.read()
+
+    return [list(row) for row in map_data.split()]
+
+
+def bfs(grid, start, end):
+    height = len(grid)
+    width = len(grid[0])
+    end_x, end_y = end
+    queue = collections.deque([[start]])
+    visited = set([start])
+
+    while queue:
+        path = queue.popleft()
+        x, y = path[-1]
+        if x == end_x and y == end_y:
+            return path
+        for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
+            nx, ny = x + dx, y + dy
+            if (
+                0 <= nx < height
+                and 0 <= ny < width
+                and grid[nx][ny] != "#"
+                and (nx, ny) not in visited
+            ):
+                queue.append(path + [(nx, ny)])
+                visited.add((nx, ny))
+    return path
+
+
+def find_pos(grid, el):
+    for row_ind, row in enumerate(grid):
+        for col_ind, cell in enumerate(row):
+            if cell == el:
+                return (row_ind, col_ind)
+
+
+def is_within_bounds(point_x, point_y, max_row, max_col):
+    return 0 <= point_x < max_row and 0 <= point_y < max_col
+
+
+def find_cheat_positions(racepath, field, max_row, max_col, threshold):
+    start_ind = racepath.index(field)
+    x, y = field
+
+    pos = set()
+    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
+    for dx1, dy1 in directions:
+        nx1, ny1 = x + dx1, y + dy1
+        if is_within_bounds(nx1, ny1, max_row, max_col):
+            for dx2, dy2 in directions:
+                nx2, ny2 = nx1 + dx2, ny1 + dy2
+                # check if is back on normal track again
+                if (
+                    is_within_bounds(nx2, ny2, max_row, max_col)
+                    and (nx2, ny2) in racepath
+                ):
+                    end_ind = racepath.index((nx2, ny2))
+                    if start_ind - end_ind - 2 >= threshold:
+                        # we need to spend 2 picoseconds for the cheating
+                        pos.add(((x, y), (nx2, ny2)))
+    return pos
+
+
+def cheat_threshold(racetrack, threshold):
+    start = find_pos(racetrack, "S")
+    end = find_pos(racetrack, "E")
+    racepath = bfs(
+        racetrack, start, end
+    )  # there is only a single path from the start to the end
+    max_row = len(racetrack)
+    max_col = len(racetrack[0])
+
+    pos = set()
+    for field in racepath:
+        pos.update(find_cheat_positions(racepath, field, max_row, max_col, threshold))
+
+    return pos
+
+
+if "__main__" == __name__:
+    racetrack = load_map("Day_20/puzzle_input.txt")
+    pos = cheat_threshold(racetrack, 100)
+    print(len(pos))

Day_20/test_task_20a.py

@@ -0,0 +1,25 @@
+from task_20a import load_map, cheat_threshold
+
+import pytest
+
+
+@pytest.mark.parametrize(
+    "threshold,expected",
+    [
+        (64, 1),
+        (40, 2),
+        (38, 3),
+        (36, 4),
+        (20, 5),
+        (12, 8),
+        (10, 10),
+        (8, 14),
+        (6, 16),
+        (4, 30),
+        (2, 44),
+    ],
+)
+def test_cheat_threshold(threshold, expected):
+    racetrack = load_map("Day_20/example_20a.txt")
+    pos = cheat_threshold(racetrack, threshold)
+    assert len(pos) == expected

README.md

@@ -95,3 +95,7 @@ The [match](https://docs.python.org/3/tutorial/controlflow.html#tut-match) state
 
 
 Brute force was good enough, so I stuck with it. Apparently, you can practically reuse part 2 from day 16 (you just need to remove the condition about 1000 points → [🔗](https://www.reddit.com/r/adventofcode/comments/1hguacy/comment/m2q835j/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button)), but I don’t have that part ready yet, so we’ll see in the future 😅
+
+## Day 20
+Part 1: I forgot that two picoseconds are needed for the cheating, so the distance isn’t simply the difference between the end position index and the start position index—we need to reduce it by 2.
+