Day 6

Author: prevostc

mygrid/src/direction.rs

@@ -98,6 +98,16 @@ impl Direction {
         self.vertical += other.vertical;
         self.horizontal += other.horizontal;
     }
+
+    #[inline]
+    pub fn to_u8(&self) -> u8 {
+        ((self.vertical + 1) << 2) as u8 | ((self.horizontal + 1) as u8)
+    }
+
+    #[inline]
+    pub fn from_u8(value: u8) -> Self {
+        Direction::new(((value >> 2) as isize) - 1, (value & 0b11) as isize - 1)
+    }
 }
 
 impl Hash for Direction {

mygrid/src/point.rs

@@ -71,6 +71,19 @@ impl Point {
         (a.line == b.line && a.line == self.line && is_between_columns)
             || (a.column == b.column && a.column == self.column && is_between_lines)
     }
+
+    #[inline]
+    pub fn to_u128(&self) -> u128 {
+        ((self.line as u128) << 64) | (self.column as u128)
+    }
+
+    #[inline]
+    pub fn from_u128(value: u128) -> Self {
+        Point::new(
+            (value >> 64) as isize,
+            (value & 0xFFFFFFFFFFFFFFFF) as isize,
+        )
+    }
 }
 
 impl Hash for Point {

src/bin/06.rs

@@ -54,7 +54,7 @@ fn get_guard_path_positions_assuming_no_loops(
         direction: UP,
     };
     let mut visited = FxHashSet::with_capacity_and_hasher(10_000, Default::default());
-    let mut jump_table = JumpTable::default();
+    let mut jump_table = JumpTable::with_capacity_and_hasher(10_000, Default::default());
     let mut old_guard = guard.clone();
 
     while let Some(new_guard) = guard.turn(grid) {
@@ -68,29 +68,6 @@ fn get_guard_path_positions_assuming_no_loops(
     (visited, jump_table)
 }
 
-#[inline]
-fn has_loops(grid: &Grid<char>, start_pos: Point, jump_table: &JumpTable) -> bool {
-    // remove entries from jump_table that contain pos between key and value
-    let mut guard = Guard {
-        position: start_pos,
-        direction: UP,
-    };
-
-    let mut visited = FxHashSet::with_capacity_and_hasher(10_000, Default::default());
-    visited.insert(guard.clone());
-
-    while let Some(new_guard) = guard.turn(&grid) {
-        guard = new_guard;
-        if !visited.insert(guard.clone()) {
-            return true;
-        }
-        if let Some(next_guard) = jump_table.get(&guard) {
-            guard = next_guard.clone();
-        }
-    }
-    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);
@@ -105,15 +82,33 @@ pub fn part_two(input: &str) -> Option<u32> {
         .par_iter()
         .filter(|&&pos| {
             let mut grid = grid.clone();
-            let jump_table: JumpTable = JumpTable::from_iter(
-                jump_table
-                    .iter()
-                    .filter(|(key, val)| !pos.is_between_inclusive(&key.position, &val.position))
-                    .map(|(key, val)| (key.clone(), val.clone())),
-            );
             grid[pos] = 'O';
 
-            has_loops(&grid, pos, &jump_table)
+            let jump_table: JumpTable = jump_table
+                .iter()
+                .filter(|(key, val)| !pos.is_between_inclusive(&key.position, &val.position))
+                .map(|(key, val)| (key.clone(), val.clone()))
+                .collect();
+
+            // remove entries from jump_table that contain pos between key and value
+            let mut guard = Guard {
+                position: start_pos,
+                direction: UP,
+            };
+
+            let mut visited = FxHashSet::with_capacity_and_hasher(10_000, Default::default());
+            visited.insert(guard.clone());
+
+            while let Some(new_guard) = guard.turn(&grid) {
+                guard = new_guard;
+                if !visited.insert(guard.clone()) {
+                    return true;
+                }
+                if let Some(next_guard) = jump_table.get(&guard) {
+                    guard = next_guard.clone();
+                }
+            }
+            false
         })
         .count();