Day 6

Author: prevostc

.vscode/launch.json

@@ -7,13 +7,13 @@
         {
             "type": "lldb",
             "request": "launch",
-            "name": "Debug unit tests for a solution",
+            "name": "Debug unit tests for solution 06",
             "cargo": {
                 "args": [
                     "test",
                     "--no-run",
                     // replace `01` here with the solution you like to debug.
-                    "--bin=01",
+                    "--bin=06",
                     "--package=advent_of_code"
                 ],
             },

README.md

@@ -16,8 +16,9 @@ Solutions for [Advent of Code](https://adventofcode.com/) in [Rust](https://www.
 | [Day 3](./src/bin/03.rs) | `717.8µs` | `830.1µs` |
 | [Day 4](./src/bin/04.rs) | `810.2µs` | `298.7µs` |
 | [Day 5](./src/bin/05.rs) | `67.7µs` | `184.5µs` |
+| [Day 6](./src/bin/06.rs) | `71.4µs` | `167.3ms` |
 
-**Total: 3.41ms**
+**Total: 170.78ms**
 <!--- benchmarking table --->
 
 ---

data/examples/06.txt

@@ -0,0 +1,10 @@
+....#.....
+.........#
+..........
+..#.......
+.......#..
+..........
+.#..^.....
+........#.
+#.........
+......#...

mygrid/src/direction.rs

@@ -3,7 +3,7 @@ use std::ops::{Add, Mul};
 
 use crate::point::Point;
 
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Default)]
 pub struct Direction {
     pub vertical: isize,
     pub horizontal: isize,

mygrid/src/grid.rs

@@ -22,7 +22,6 @@ impl<T> Grid<T> {
             content: vec![default; width * height],
         }
     }
-
     #[inline]
     pub fn new_from_str<F>(input: &str, map_char: F) -> Self
     where
@@ -48,7 +47,7 @@ impl<T> Grid<T> {
     pub fn new_from_str_capture_start(
         input: &str,
         map_char: &dyn Fn(char) -> T,
-        is_start: &dyn Fn(T) -> bool,
+        is_start: &dyn Fn(char) -> bool,
     ) -> (Self, Point)
     where
         T: From<char> + Copy,
@@ -59,7 +58,7 @@ impl<T> Grid<T> {
         let mut start = None;
         for (i, c) in input.chars().filter(|&c| c != '\n').enumerate() {
             let t = map_char(c);
-            if is_start(t) {
+            if is_start(c) {
                 start = Some(Point::new_usize(i / width, i % width));
             }
             content.push(t);
@@ -160,6 +159,13 @@ impl<T> Grid<T> {
     }
 }
 
+impl Grid<char> {
+    #[inline]
+    pub fn new_char_grid_from_str(input: &str) -> Self {
+        Self::new_from_str(input, |c| c)
+    }
+}
+
 impl<T> Grid<T> {
     #[inline]
     pub fn is_in_bounds(&self, point: Point) -> bool {
@@ -254,6 +260,22 @@ impl<T: std::fmt::Display> std::fmt::Display for Grid<T> {
     }
 }
 
+impl<T: std::fmt::Display> std::fmt::Debug for Grid<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+impl<T: PartialEq> Grid<T> {
+    #[inline]
+    pub fn find_position_of(&self, item: &T) -> Option<Point> {
+        self.content
+            .iter()
+            .position(|t| *t == *item)
+            .map(|i| Point::new_usize(i / self.width, i % self.width))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -517,4 +539,27 @@ mod tests {
         assert_eq!(grid.content[2], '8');
         assert_eq!(grid.content[3], '9');
     }
+
+    #[test]
+    pub fn test_grid_get_item() {
+        let grid = Grid::new_from_str("123\n456\n789", &|c| c);
+        assert_eq!(grid.get_item(Point::new(0, 0)), Some(&'1'));
+        assert_eq!(grid.get_item(Point::new(0, 1)), Some(&'2'));
+        assert_eq!(grid.get_item(Point::new(0, 2)), Some(&'3'));
+    }
+
+    #[test]
+    pub fn test_grid_get_item_out_of_bounds() {
+        let grid = Grid::new_from_str("123\n456\n789", &|c| c);
+        assert_eq!(grid.get_item(Point::new(3, 0)), None);
+        assert_eq!(grid.get_item(Point::new(0, 3)), None);
+    }
+
+    #[test]
+    pub fn test_grid_find_position_of() {
+        let grid = Grid::new_from_str("123\n456\n789", &|c| c);
+        assert_eq!(grid.find_position_of(&'1'), Some(Point::new(0, 0)));
+        assert_eq!(grid.find_position_of(&'2'), Some(Point::new(0, 1)));
+        assert_eq!(grid.find_position_of(&'3'), Some(Point::new(0, 2)));
+    }
 }

mygrid/src/point.rs

@@ -7,7 +7,7 @@ use std::hash::{Hash, Hasher};
 
 use crate::direction::Direction;
 
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Default)]
 pub struct Point {
     pub line: isize,
     pub column: isize,
@@ -100,23 +100,23 @@ mod tests {
         assert_eq!(min.column, 1);
     }
 
-    #[test]
-    pub fn test_infinite_grid_to_real_grid() {
-        let point = Point::new(45, 20);
-        let real_grid_lines = 3;
-        let real_grid_columns = 4;
-        let real_grid_point = point.infinite_grid_to_real_grid(real_grid_lines, real_grid_columns);
-        assert_eq!(real_grid_point.line, 0);
-        assert_eq!(real_grid_point.column, 0);
-    }
-
-    #[test]
-    pub fn test_infinite_grid_to_real_grid_negative() {
-        let point = Point::new(-5, -8);
-        let real_grid_lines = 3;
-        let real_grid_columns = 4;
-        let real_grid_point = point.infinite_grid_to_real_grid(real_grid_lines, real_grid_columns);
-        assert_eq!(real_grid_point.line, 1);
-        assert_eq!(real_grid_point.column, 0);
-    }
+    // #[test]
+    // pub fn test_infinite_grid_to_real_grid() {
+    //     let point = Point::new(45, 20);
+    //     let real_grid_lines = 3;
+    //     let real_grid_columns = 4;
+    //     let real_grid_point = point.infinite_grid_to_real_grid(real_grid_lines, real_grid_columns);
+    //     assert_eq!(real_grid_point.line, 0);
+    //     assert_eq!(real_grid_point.column, 0);
+    // }
+
+    // #[test]
+    // pub fn test_infinite_grid_to_real_grid_negative() {
+    //     let point = Point::new(-5, -8);
+    //     let real_grid_lines = 3;
+    //     let real_grid_columns = 4;
+    //     let real_grid_point = point.infinite_grid_to_real_grid(real_grid_lines, real_grid_columns);
+    //     assert_eq!(real_grid_point.line, 1);
+    //     assert_eq!(real_grid_point.column, 0);
+    // }
 }

src/bin/06.rs

@@ -0,0 +1,116 @@
+advent_of_code::solution!(6);
+use mygrid::direction::{Direction, UP};
+use mygrid::grid::Grid;
+use mygrid::point::Point;
+use rustc_hash::FxHashSet;
+
+#[derive(Default, Clone, PartialEq, Eq, Hash)]
+struct Guard {
+    position: Point,
+    direction: Direction,
+}
+
+impl Guard {
+    fn turn(&self, grid: &Grid<char>) -> Option<Guard> {
+        let mut dir = self.direction;
+        for _ in 0..5 {
+            let next_pos = self.position.apply_direction(dir);
+
+            let Some(&next_direction) = grid.get_item(next_pos) else {
+                continue;
+            };
+            if next_direction == '.' {
+                return Some(Guard {
+                    position: next_pos,
+                    direction: dir,
+                });
+            }
+            dir = dir.rotate_clockwise();
+        }
+        None
+    }
+}
+
+fn parse_grid_and_start_pos(input: &str) -> (Grid<char>, Point) {
+    Grid::new_from_str_capture_start(
+        input,
+        &|c| match c {
+            '^' => '.',
+            _ => c,
+        },
+        &|c| c == '^',
+    )
+}
+
+fn get_guard_path_positions_assuming_no_loops(
+    grid: &Grid<char>,
+    start_pos: Point,
+) -> FxHashSet<Point> {
+    let mut guard = Guard {
+        position: start_pos,
+        direction: UP,
+    };
+    let mut visited = FxHashSet::default();
+    visited.insert(guard.position);
+
+    while let Some(new_guard) = guard.turn(grid) {
+        guard = new_guard;
+        visited.insert(guard.position);
+    }
+    visited
+}
+
+fn does_start_pos_loop(grid: &Grid<char>, start_pos: Point) -> bool {
+    let mut guard = Guard {
+        position: start_pos,
+        direction: UP,
+    };
+    let mut visited = FxHashSet::default();
+    visited.insert(guard.clone());
+
+    while let Some(new_guard) = guard.turn(grid) {
+        guard = new_guard;
+        if !visited.insert(guard.clone()) {
+            return true;
+        }
+    }
+    false
+}
+
+pub fn part_one(input: &str) -> Option<u32> {
+    let (grid, start_pos) = parse_grid_and_start_pos(input);
+    let visited = get_guard_path_positions_assuming_no_loops(&grid, start_pos);
+    Some(visited.len() as u32)
+}
+
+pub fn part_two(input: &str) -> Option<u32> {
+    let (mut grid, start_pos) = parse_grid_and_start_pos(input);
+    let positions_to_check = get_guard_path_positions_assuming_no_loops(&grid, start_pos);
+
+    let mut count = 0;
+    for pos in positions_to_check {
+        grid[pos] = 'O';
+        if does_start_pos_loop(&grid, start_pos) {
+            count += 1;
+        }
+        grid[pos] = '.';
+    }
+    Some(count)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_part_one() {
+        let result = part_one(&advent_of_code::template::read_file("examples", DAY));
+        assert_eq!(result, Some(41));
+    }
+
+    #[test]
+    fn test_part_two() {
+        let result = part_two(&advent_of_code::template::read_file("examples", DAY));
+        assert_eq!(result, Some(6));
+    }
+}