Day 13, Part 2

README.md

@@ -54,6 +54,7 @@ Compiled using clang 16 and LTO.
 | 10  | 5.8 ms          | 16.4 ms               |
 | 11  | 980 µs          | 1.7 ms                |
 | 12  | 347 ms          | 554 ms                |
+| 13  | 248 µs          |                       |
 
 ## 🙏 Acknowledgments and Resources
 

justfile

@@ -6,6 +6,10 @@ _default:
 watch:
     fd ".*c$" -t f | entr ninja -C build test
 
+watch-latest:
+    #!/usr/bin/env bash
+    fd ".*c$" -t f | entr -s "just test-latest && notify-send -t 5000 'AoC tests ok'"
+
 generate DAY:
     #!/usr/bin/env bash
     set -eu

puzzle/day13.md

@@ -5,11 +5,11 @@ With your help, the hot springs team locates an appropriate spring which launche
 
 There's just one problem: you don't see any lava.
 
-You do see a lot of ash and igneous rock; there are even what look like gray mountains scattered around. After a while, you make your way to a nearby cluster of mountains only to discover that
-the valley between them is completely full of large mirrors. Most of the mirrors seem to be aligned in a consistent way; perhaps you should head in that direction?
+You do see a lot of ash and igneous rock; there are even what look like gray mountains scattered around. After a while, you make your way to a nearby cluster of mountains only to discover that the valley between them is completely full of large mirrors. Most of the mirrors seem
+to be aligned in a consistent way; perhaps you should head in that direction?
 
-As you move through the valley of mirrors, you find that several of them have fallen from the large metal frames keeping them in place. The mirrors are extremely flat and shiny, and many of
-the fallen mirrors have lodged into the ash at strange angles. Because the terrain is all one color, it's hard to tell where it's safe to walk or where you're about to run into a mirror.
+As you move through the valley of mirrors, you find that several of them have fallen from the large metal frames keeping them in place. The mirrors are extremely flat and shiny, and many of the fallen mirrors have lodged into the ash at strange angles. Because the terrain is all
+one color, it's hard to tell where it's safe to walk or where you're about to run into a mirror.
 
 You note down the patterns of ash (.) and rocks (#) that you see as you walk (your puzzle input); perhaps by carefully analyzing these patterns, you can figure out where the mirrors are!
 
@@ -47,9 +47,8 @@ In the first pattern, the reflection is across a vertical line between two colum
     ><   
 123456789
 
-In this pattern, the line of reflection is the vertical line between columns 5 and 6. Because the vertical line is not perfectly in the middle of the pattern, part of the pattern (column 1)
-has nowhere to reflect onto and can be ignored; every other column has a reflected column within the pattern and must match exactly: column 2 matches column 9, column 3 matches 8, 4 matches 7,
-and 5 matches 6.
+In this pattern, the line of reflection is the vertical line between columns 5 and 6. Because the vertical line is not perfectly in the middle of the pattern, part of the pattern (column 1) has nowhere to reflect onto and can be ignored; every other column has a reflected column
+within the pattern and must match exactly: column 2 matches column 9, column 3 matches 8, 4 matches 7, and 5 matches 6.
 
 The second pattern reflects across a horizontal line instead:
 
@@ -61,26 +60,23 @@ The second pattern reflects across a horizontal line instead:
 6 ..##..### 6
 7 #....#..# 7
 
-This pattern reflects across the horizontal line between rows 4 and 5. Row 1 would reflect with a hypothetical row 8, but since that's not in the pattern, row 1 doesn't need to match anything.
-The remaining rows match: row 2 matches row 7, row 3 matches row 6, and row 4 matches row 5.
+This pattern reflects across the horizontal line between rows 4 and 5. Row 1 would reflect with a hypothetical row 8, but since that's not in the pattern, row 1 doesn't need to match anything. The remaining rows match: row 2 matches row 7, row 3 matches row 6, and row 4 matches
+row 5.
 
-To summarize your pattern notes, add up the number of columns to the left of each vertical line of reflection; to that, also add 100 multiplied by the number of rows above each horizontal line
-of reflection. In the above example, the first pattern's vertical line has 5 columns to its left and the second pattern's horizontal line has 4 rows above it, a total of 405.
+To summarize your pattern notes, add up the number of columns to the left of each vertical line of reflection; to that, also add 100 multiplied by the number of rows above each horizontal line of reflection. In the above example, the first pattern's vertical line has 5 columns
+to its left and the second pattern's horizontal line has 4 rows above it, a total of 405.
 
 Find the line of reflection in each of the patterns in your notes. What number do you get after summarizing all of your notes?
 
 Your puzzle answer was 35210.
 
-The first half of this puzzle is complete! It provides one gold star: *
-
 --- Part Two ---
 
 You resume walking through the valley of mirrors and - SMACK! - run directly into one. Hopefully nobody was watching, because that must have been pretty embarrassing.
 
 Upon closer inspection, you discover that every mirror has exactly one smudge: exactly one . or # should be the opposite type.
 
-In each pattern, you'll need to locate and fix the smudge that causes a different reflection line to be valid. (The old reflection line won't necessarily continue being valid after the smudge
-is fixed.)
+In each pattern, you'll need to locate and fix the smudge that causes a different reflection line to be valid. (The old reflection line won't necessarily continue being valid after the smudge is fixed.)
 
 Here's the above example again:
 
@@ -110,8 +106,8 @@ The first pattern's smudge is in the top-left corner. If the top-left # were ins
 6 ..##..##. 6
 7 #.#.##.#. 7
 
-With the smudge in the top-left corner repaired, a new horizontal line of reflection between rows 3 and 4 now exists. Row 7 has no corresponding reflected row and can be ignored, but every
-other row matches exactly: row 1 matches row 6, row 2 matches row 5, and row 3 matches row 4.
+With the smudge in the top-left corner repaired, a new horizontal line of reflection between rows 3 and 4 now exists. Row 7 has no corresponding reflected row and can be ignored, but every other row matches exactly: row 1 matches row 6, row 2 matches row 5, and row 3 matches row
+4.
 
 In the second pattern, the smudge can be fixed by changing the fifth symbol on row 2 from . to #:
 
@@ -125,14 +121,17 @@ In the second pattern, the smudge can be fixed by changing the fifth symbol on r
 
 Now, the pattern has a different horizontal line of reflection between rows 1 and 2.
 
-Summarize your notes as before, but instead use the new different reflection lines. In this example, the first pattern's new horizontal line has 3 rows above it and the second pattern's new
-horizontal line has 1 row above it, summarizing to the value 400.
+Summarize your notes as before, but instead use the new different reflection lines. In this example, the first pattern's new horizontal line has 3 rows above it and the second pattern's new horizontal line has 1 row above it, summarizing to the value 400.
 
 In each pattern, fix the smudge and find the different line of reflection. What number do you get after summarizing the new reflection line in each pattern in your notes?
 
-Answer:
+Your puzzle answer was 31974.
+
+Both parts of this puzzle are complete! They provide two gold stars: **
+
+At this point, you should return to your Advent calendar and try another puzzle.
 
-Although it hasn't changed, you can still get your puzzle input.
+If you still want to see it, you can get your puzzle input.
 
 You can also [Shareon Twitter Mastodon] this puzzle.
 

src/day13/solve.c

@@ -21,16 +21,11 @@ typedef struct {
     int cols;
 } grid_t;
 
-/*
-static void print_grid(const grid_t *grid) {
-    for (int y = 0; y < grid->rows; y++) {
-        for (int x = 0; x < grid->cols; x++) { printf("%c", grid->data[y][x]); }
-        puts("");
-    }
-}
-*/
-
-static bool is_perfect_vertical(const grid_t *grid, int x) {
+// Check if we the vertical line at 'x' is perfect.
+// Returns the number of incorrect reflections. If it's zero, the line is
+// perfect.
+static int is_perfect_vertical(const grid_t *grid, int x) {
+    int wrong_count = 0;
     // x denotes the position of the > in ><
     int delta = 0;
     while (1) {
@@ -39,14 +34,18 @@ static bool is_perfect_vertical(const grid_t *grid, int x) {
         if (x_left < 0 || x_right >= grid->cols) break;
         // compare columns
         for (int y = 0; y < grid->rows; y++) {
-            if (grid->data[y][x_left] != grid->data[y][x_right]) return false;
+            if (grid->data[y][x_left] != grid->data[y][x_right]) { wrong_count++; }
         }
         delta++;
     }
-    return true;
+    return wrong_count;
 }
 
-static bool is_perfect_horizontal(const grid_t *grid, int y) {
+// Check if we the horizontal line at 'y' is perfect.
+// Returns the number of incorrect reflections. If it's zero, the line is
+// perfect.
+static int is_perfect_horizontal(const grid_t *grid, int y) {
+    int wrong_count = 0;
     // y denotes the position of the v
     int delta = 0;
     while (1) {
@@ -55,11 +54,11 @@ static bool is_perfect_horizontal(const grid_t *grid, int y) {
         if (y_top < 0 || y_down >= grid->rows) break;
         // compare rows
         for (int x = 0; x < grid->cols; x++) {
-            if (grid->data[y_top][x] != grid->data[y_down][x]) return false;
+            if (grid->data[y_top][x] != grid->data[y_down][x]) { wrong_count++; }
         }
         delta++;
     }
-    return true;
+    return wrong_count;
 }
 
 void solve(const char *buf, size_t buf_size, Solution *result) {
@@ -80,22 +79,31 @@ void solve(const char *buf, size_t buf_size, Solution *result) {
                 break;
             }
         }
-        log_debug(">> grid has %d rows, %d cols", grid.rows, grid.cols);
 
+        bool p1_done = false;
+        bool p2_done = false;
         for (int x = 0; x < grid.cols - 1; x++) {
-            if (is_perfect_vertical(&grid, x)) {
-                int col = x + 1;
-                log_debug("found perfect vertical reflection between %d and %d", col, col + 1);
+            if (p1_done && p2_done) continue;
+            int wrong_count = is_perfect_vertical(&grid, x);
+            int col = x + 1;
+            if (wrong_count == 0) {
                 part1 += col;
-                break;
+                p1_done = true;
+            } else if (wrong_count == 1) {
+                part2 += col;
+                p2_done = true;
             }
         }
         for (int y = 0; y < grid.rows - 1; y++) {
-            if (is_perfect_horizontal(&grid, y)) {
-                int row = y + 1;
-                log_debug("found perfect horizontal reflection between %d and %d", row, row + 1);
+            if (p1_done && p2_done) continue;
+            int wrong_count = is_perfect_horizontal(&grid, y);
+            int row = y + 1;
+            if (wrong_count == 0) {
                 part1 += 100 * row;
-                break;
+                p1_done = true;
+            } else if (wrong_count == 1) {
+                part2 += 100 * row;
+                p2_done = true;
             }
         }
     }

src/day13/solve_test.c

@@ -30,15 +30,15 @@ CTEST(day13, example) {
     Solution solution;
     solve(buf, strlen(buf), &solution);
     ASSERT_STR("405", solution.part1);
-    // ASSERT_STR("0", solution.part2);
+    ASSERT_STR("400", solution.part2);
 }
 
 #ifdef HAVE_INPUTS
 CTEST(day13, real) {
     Solution solution;
     solve_input("input/" DAY ".txt", &solution);
     ASSERT_STR("35210", solution.part1);
-    // ASSERT_STR("0", solution.part2);
+    ASSERT_STR("31974", solution.part2);
 }
 #endif