Complete day 10

diff --git a/src/day10.rs b/src/day10.rs
new file mode 100644 (file)
index 0000000..7848b25
--- /dev/null
+++ b/src/day10.rs
@@ -0,0 +1,190 @@
+use std::collections::{HashSet, VecDeque};
+use std::ops::{Add, Index, Sub};
+
+fn input() -> &'static str {
+    include_str!("../input/day10.txt")
+}
+
+#[derive(Debug, Hash, Eq, PartialEq, Copy, Clone)]
+struct Point(i32, i32);
+
+#[rustfmt::skip]
+const DIRS: [Point; 4] = [
+                Point(-1, 0),
+     Point(0, -1), /* ctr */ Point(0, 1),
+                Point( 1, 0),
+];
+
+impl Point {
+    fn in_bounds(&self, bound: usize) -> bool {
+        let bound: i32 = bound.try_into().unwrap();
+        self.0 >= 0 && self.1 >= 0 && self.0 < bound && self.1 < bound
+    }
+
+    fn adjacent(self, bound: usize) -> impl Iterator<Item = Point> {
+        DIRS.iter()
+            .copied()
+            .map(move |d| d + self)
+            .filter(move |p| p.in_bounds(bound))
+    }
+}
+
+impl Add for Point {
+    type Output = Point;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Point(self.0 + rhs.0, self.1 + rhs.1)
+    }
+}
+
+impl Sub for Point {
+    type Output = Point;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        Point(self.0 - rhs.0, self.1 - rhs.1)
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, Clone)]
+struct Map(Vec<Vec<u8>>);
+
+impl Index<Point> for Map {
+    type Output = u8;
+
+    fn index(&self, index: Point) -> &Self::Output {
+        let i: usize = index.0.try_into().unwrap();
+        let j: usize = index.1.try_into().unwrap();
+        &self.0[i][j]
+    }
+}
+
+fn parse(input: &str) -> Map {
+    Map(input
+        .lines()
+        .map(|l| l.chars().map(|c| c.to_string().parse().unwrap()).collect())
+        .collect())
+}
+
+fn find_height(map: &Map, height: u8) -> impl Iterator<Item = Point> + use<'_> {
+    map.0.iter().zip(0..).flat_map(move |(v, i)| {
+        v.iter()
+            .zip(0..)
+            .filter(move |(&c, _)| c == height)
+            .map(move |(_, j)| Point(i, j))
+    })
+}
+
+fn walk_paths(map: &Map, root: &Point) -> Vec<Point> {
+    let bound = map.0.len();
+    let mut adjits = VecDeque::from([root.adjacent(bound)]);
+    let mut adjs: Vec<Point> = vec![];
+    for n in 1..=9 {
+        while let Some(adj) = adjits.pop_front() {
+            adjs.extend(adj);
+        }
+        if n < 9 {
+            while let Some(p) = adjs.pop() {
+                if map[p] == n {
+                    adjits.push_back(p.adjacent(bound))
+                }
+            }
+        }
+    }
+    adjs.iter().filter(|&&p| map[p] == 9).copied().collect()
+}
+
+fn count_trails(map: &Map, root: &Point) -> u64 {
+    walk_paths(map, root)
+        .iter()
+        .collect::<HashSet<_>>()
+        .len()
+        .try_into()
+        .unwrap()
+}
+
+fn count_unique_trails(map: &Map, root: &Point) -> u64 {
+    walk_paths(map, root).len().try_into().unwrap()
+}
+
+pub fn part1() {
+    let map = parse(input());
+    let n: u64 = find_height(&map, 0).map(|p| count_trails(&map, &p)).sum();
+    println!("Day 10 Part 1: {}", n);
+}
+
+pub fn part2() {
+    let map = parse(input());
+    let n: u64 = find_height(&map, 0)
+        .map(|p| count_unique_trails(&map, &p))
+        .sum();
+    println!("Day 10 Part 2: {}", n);
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    const TINY_INPUT: &str = concat!("0123\n", "1234\n", "8765\n", "9876\n",);
+
+    const INPUT_STR: &str = concat!(
+        "89010123\n",
+        "78121874\n",
+        "87430965\n",
+        "96549874\n",
+        "45678903\n",
+        "32019012\n",
+        "01329801\n",
+        "10456732\n",
+    );
+
+    #[test]
+    fn test_parse() {
+        assert_eq!(
+            parse(INPUT_STR),
+            Map(vec![
+                vec![8, 9, 0, 1, 0, 1, 2, 3],
+                vec![7, 8, 1, 2, 1, 8, 7, 4],
+                vec![8, 7, 4, 3, 0, 9, 6, 5],
+                vec![9, 6, 5, 4, 9, 8, 7, 4],
+                vec![4, 5, 6, 7, 8, 9, 0, 3],
+                vec![3, 2, 0, 1, 9, 0, 1, 2],
+                vec![0, 1, 3, 2, 9, 8, 0, 1],
+                vec![1, 0, 4, 5, 6, 7, 3, 2]
+            ])
+        )
+    }
+
+    #[test]
+    fn test_count_trails() {
+        let map = parse(TINY_INPUT);
+        assert_eq!(count_trails(&map, &Point(0, 0)), 1);
+
+        let map = parse(INPUT_STR);
+        assert_eq!(count_trails(&map, &Point(0, 2)), 5);
+        assert_eq!(count_trails(&map, &Point(0, 4)), 6);
+        assert_eq!(count_trails(&map, &Point(2, 4)), 5);
+        assert_eq!(count_trails(&map, &Point(4, 6)), 3);
+        assert_eq!(count_trails(&map, &Point(5, 2)), 1);
+        assert_eq!(count_trails(&map, &Point(5, 5)), 3);
+        assert_eq!(count_trails(&map, &Point(6, 0)), 5);
+        assert_eq!(count_trails(&map, &Point(6, 6)), 3);
+        assert_eq!(count_trails(&map, &Point(7, 1)), 5);
+    }
+
+    #[test]
+    fn test_count_unique_trails() {
+        let map = parse(TINY_INPUT);
+        assert_eq!(count_unique_trails(&map, &Point(0, 0)), 16);
+
+        let map = parse(INPUT_STR);
+        assert_eq!(count_unique_trails(&map, &Point(0, 2)), 20);
+        assert_eq!(count_unique_trails(&map, &Point(0, 4)), 24);
+        assert_eq!(count_unique_trails(&map, &Point(2, 4)), 10);
+        assert_eq!(count_unique_trails(&map, &Point(4, 6)), 4);
+        assert_eq!(count_unique_trails(&map, &Point(5, 2)), 1);
+        assert_eq!(count_unique_trails(&map, &Point(5, 5)), 4);
+        assert_eq!(count_unique_trails(&map, &Point(6, 0)), 5);
+        assert_eq!(count_unique_trails(&map, &Point(6, 6)), 8);
+        assert_eq!(count_unique_trails(&map, &Point(7, 1)), 5);
+    }
+}

diff --git a/src/main.rs b/src/main.rs
index 0a184da097cbabcd83209a8202874fc698384fbe..f4353754473ae8ef7729f59be667ba92b90a5936 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -7,7 +7,7 @@ pub mod day06;
 pub mod day07;
 pub mod day08;
 pub mod day09;
-// pub mod day10;
+pub mod day10;
 // pub mod day11;
 // pub mod day12;
 // pub mod day13;
@@ -26,7 +26,7 @@ pub mod day09;
 
 type Part = fn();
 
-const DAYS: [(Part, Part); 9] = [
+const DAYS: &[(Part, Part)] = &[
     (day01::part1 as fn(), day01::part2 as fn()),
     (day02::part1 as fn(), day02::part2 as fn()),
     (day03::part1 as fn(), day03::part2 as fn()),
@@ -36,7 +36,7 @@ const DAYS: [(Part, Part); 9] = [
     (day07::part1 as fn(), day07::part2 as fn()),
     (day08::part1 as fn(), day08::part2 as fn()),
     (day09::part1 as fn(), day09::part2 as fn()),
-    // (day10::part1 as fn(), day10::part2 as fn()),
+    (day10::part1 as fn(), day10::part2 as fn()),
     // (day11::part1 as fn(), day11::part2 as fn()),
     // (day12::part1 as fn(), day12::part2 as fn()),
     // (day13::part1 as fn(), day13::part2 as fn()),