Year 2024 Day 10

Author: maneatingape

README.md

@@ -81,6 +81,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 7 | [Bridge Repair](https://adventofcode.com/2024/day/7) | [Source](src/year2024/day07.rs) | 136 |
 | 8 | [Resonant Collinearity](https://adventofcode.com/2024/day/8) | [Source](src/year2024/day08.rs) | 8 |
 | 9 | [Disk Fragmenter](https://adventofcode.com/2024/day/9) | [Source](src/year2024/day09.rs) | 163 |
+| 10 | [Hoof It](https://adventofcode.com/2024/day/10) | [Source](src/year2024/day10.rs) | 41 |
 
 ## 2023
 

benches/benchmark.rs

@@ -301,4 +301,5 @@ mod year2024 {
     benchmark!(year2024, day07);
     benchmark!(year2024, day08);
     benchmark!(year2024, day09);
+    benchmark!(year2024, day10);
 }

src/lib.rs

@@ -300,4 +300,5 @@ pub mod year2024 {
     pub mod day07;
     pub mod day08;
     pub mod day09;
+    pub mod day10;
 }

src/main.rs

@@ -370,5 +370,6 @@ fn year2024() -> Vec<Solution> {
         solution!(year2024, day07),
         solution!(year2024, day08),
         solution!(year2024, day09),
+        solution!(year2024, day10),
     ]
 }

src/year2024/day10.rs

@@ -0,0 +1,79 @@
+//! # Hoof It
+//!
+//! [Breadth first search](https://en.wikipedia.org/wiki/Breadth-first_search) for both parts.
+//! Part two is simpler than part one as we don't need to keep track of already visited points.
+//! My input contained fewer peaks `9` than valleys `0`` so it was slightly faster
+//! to reverse search.
+use crate::util::grid::*;
+use crate::util::point::*;
+use std::collections::VecDeque;
+
+pub fn parse(input: &str) -> Grid<u8> {
+    Grid::parse(input)
+}
+
+pub fn part1(grid: &Grid<u8>) -> u32 {
+    let mut starts = Vec::new();
+
+    for y in 0..grid.height {
+        for x in 0..grid.width {
+            let point = Point::new(x, y);
+            if grid[point] == b'9' {
+                starts.push(point);
+            }
+        }
+    }
+
+    let mut todo = VecDeque::new();
+    let mut seen = grid.same_size_with(usize::MAX);
+    let mut result = 0;
+
+    for (index, &start) in starts.iter().enumerate() {
+        todo.push_back(start);
+
+        while let Some(point) = todo.pop_front() {
+            for next in ORTHOGONAL.map(|o| point + o) {
+                if grid.contains(next) && grid[next] + 1 == grid[point] && seen[next] != index {
+                    seen[next] = index;
+
+                    if grid[next] == b'0' {
+                        result += 1;
+                    } else {
+                        todo.push_back(next);
+                    }
+                }
+            }
+        }
+    }
+
+    result
+}
+
+pub fn part2(grid: &Grid<u8>) -> u32 {
+    let mut todo = VecDeque::new();
+
+    for y in 0..grid.height {
+        for x in 0..grid.width {
+            let start = Point::new(x, y);
+            if grid[start] == b'9' {
+                todo.push_back(start);
+            }
+        }
+    }
+
+    let mut result = 0;
+
+    while let Some(point) = todo.pop_front() {
+        for next in ORTHOGONAL.map(|o| point + o) {
+            if grid.contains(next) && grid[next] + 1 == grid[point] {
+                if grid[next] == b'0' {
+                    result += 1;
+                } else {
+                    todo.push_back(next);
+                }
+            }
+        }
+    }
+
+    result
+}

tests/test.rs

@@ -290,4 +290,5 @@ mod year2024 {
     mod day07_test;
     mod day08_test;
     mod day09_test;
+    mod day10_test;
 }

tests/year2024/day10_test.rs

@@ -0,0 +1,23 @@
+use aoc::year2024::day10::*;
+
+const EXAMPLE: &str = "\
+89010123
+78121874
+87430965
+96549874
+45678903
+32019012
+01329801
+10456732";
+
+#[test]
+fn part1_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part1(&input), 36);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part2(&input), 81);
+}