Day 8

Author: prevostc

README.md

@@ -18,8 +18,9 @@ Solutions for [Advent of Code](https://adventofcode.com/) in [Rust](https://www.
 | [Day 5](./src/bin/05.rs) | `66.0µs` | `188.7µs` |
 | [Day 6](./src/bin/06.rs) | `48.5µs` | `4.2ms` |
 | [Day 7](./src/bin/07.rs) | `316.2µs` | `319.6µs` |
+| [Day 8](./src/bin/08.rs) | `7.3µs` | `15.6µs` |
 
-**Total: 5.98ms**
+**Total: 6.00ms**
 <!--- benchmarking table --->
 
 ---

data/examples/08.txt

@@ -0,0 +1,12 @@
+............
+........0...
+.....0......
+.......0....
+....0.......
+......A.....
+............
+............
+........A...
+.........A..
+............
+............

mygrid/src/point.rs

@@ -84,6 +84,16 @@ impl Point {
             (value & 0xFFFFFFFFFFFFFFFF) as isize,
         )
     }
+
+    #[inline]
+    pub fn as_direction(&self) -> Direction {
+        Direction::new(self.line, self.column)
+    }
+
+    #[inline]
+    pub fn as_vector_direction(&self, other: &Point) -> Direction {
+        Direction::new(other.line - self.line, other.column - self.column)
+    }
 }
 
 impl Hash for Point {

src/bin/08.rs

@@ -0,0 +1,71 @@
+use advent_of_code::into_group_map_heapless;
+use heapless::FnvIndexMap as HeaplessHashMap;
+use heapless::FnvIndexSet as HeaplessHashSet;
+use heapless::Vec as HeaplessVec;
+use itertools::Itertools;
+use mygrid::grid::Grid;
+use mygrid::point::Point;
+advent_of_code::solution!(8);
+
+const MAX_ANTENNA_TYPES: usize = 64;
+const MAX_ANTENNA_PER_TYPE: usize = 16;
+type AntennaMap<'a> =
+    HeaplessHashMap<&'a char, HeaplessVec<Point, MAX_ANTENNA_PER_TYPE>, MAX_ANTENNA_TYPES>;
+
+fn solve<const PART1: bool>(input: &str) -> Option<u32> {
+    let grid = Grid::new_char_grid_from_str(input);
+
+    let antennas: AntennaMap = into_group_map_heapless(
+        grid.iter_item_and_position()
+            .filter(|(_, &c)| c != '.')
+            .map(|(point, c)| (c, point)),
+    );
+
+    let mut pos_set: HeaplessHashSet<Point, 2048> = HeaplessHashSet::new();
+    for (_, vec) in antennas.iter() {
+        for (a, b) in vec.iter().tuple_combinations() {
+            for (a, b) in [(a, b), (b, a)] {
+                let dir = b.as_vector_direction(a);
+                let mut p = *a + dir;
+                if PART1 {
+                    if grid.is_in_bounds(p) {
+                        pos_set.insert(p).unwrap();
+                    }
+                } else {
+                    pos_set.insert(*a).unwrap();
+                    pos_set.insert(*b).unwrap();
+                    while grid.is_in_bounds(p) {
+                        pos_set.insert(p).unwrap();
+                        p = p + dir;
+                    }
+                }
+            }
+        }
+    }
+
+    Some(pos_set.len() as u32)
+}
+pub fn part_one(input: &str) -> Option<u32> {
+    solve::<true>(input)
+}
+
+pub fn part_two(input: &str) -> Option<u32> {
+    solve::<false>(input)
+}
+
+#[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(14));
+    }
+
+    #[test]
+    fn test_part_two() {
+        let result = part_two(&advent_of_code::template::read_file("examples", DAY));
+        assert_eq!(result, Some(34));
+    }
+}

src/lib.rs

@@ -1,3 +1,31 @@
 pub mod template;
+use std::fmt::Debug;
+use std::hash::Hash;
+
+use heapless::FnvIndexMap as HeaplessHashMap;
+use heapless::Vec as HeaplessVec;
 
 // Use this file to add helper functions and additional modules.
+
+pub fn into_group_map_heapless<const M: usize, const N: usize, I, K, V>(
+    iter: I,
+) -> HeaplessHashMap<K, HeaplessVec<V, M>, N>
+where
+    V: Clone + Debug,
+    I: Iterator<Item = (K, V)>,
+    K: Hash + Eq + Debug,
+{
+    let mut lookup: HeaplessHashMap<K, HeaplessVec<V, M>, N> = HeaplessHashMap::new();
+
+    iter.for_each(|(key, val)| {
+        if let Some(vec) = lookup.get_mut(&key) {
+            vec.push(val).unwrap();
+        } else {
+            let mut vec = HeaplessVec::new();
+            vec.push(val).unwrap();
+            lookup.insert(key, vec).unwrap();
+        }
+    });
+
+    lookup
+}