2025 Day 7 cleaned

Author: hsaikia

src/bin/2025_07/main.rs

@@ -1,11 +1,13 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 
 use aoc::{
-    common,
+    common::{self, HashMapCount},
     grid::{CellIndex, Grid},
 };
+use itertools::Itertools;
 
-fn solve2(input: &str) -> usize {
+fn solve(input: &str) -> (usize, usize) {
+    let mut ans1 = 0;
     let mut ans2 = 0;
     let grid = Grid::from_str(input, |c| c);
     let mut pos = grid.positions(&'S');
@@ -22,28 +24,16 @@ fn solve2(input: &str) -> usize {
         for (p, t) in space_time {
             if empty_spaces.contains(&p) {
                 let new_p = (p.0 + 1, p.1);
-                if let Some(x) = new_space_time.get_mut(&new_p) {
-                    *x += t;
-                } else {
-                    new_space_time.insert(new_p, t);
-                }
+                new_space_time.insert_with_count(&new_p, t);
             }
             if tachyons.contains(&p) {
                 if p.1 > 0 {
                     let new_p = (p.0 + 1, p.1 - 1);
-                    if let Some(x) = new_space_time.get_mut(&new_p) {
-                        *x += t;
-                    } else {
-                        new_space_time.insert(new_p, t);
-                    }
+                    new_space_time.insert_with_count(&new_p, t);
                 }
                 if p.1 + 1 < grid.cols {
                     let new_p = (p.0 + 1, p.1 + 1);
-                    if let Some(x) = new_space_time.get_mut(&new_p) {
-                        *x += t;
-                    } else {
-                        new_space_time.insert(new_p, t);
-                    }
+                    new_space_time.insert_with_count(&new_p, t);
                 }
             }
         }
@@ -52,59 +42,21 @@ fn solve2(input: &str) -> usize {
             break;
         }
 
+        ans1 += tachyons
+            .iter()
+            .filter(|x| new_space_time.keys().contains(x))
+            .count();
         ans2 = new_space_time.values().sum::<usize>();
         space_time = new_space_time;
     }
 
     //grid.print();
-    ans2
-}
-
-fn solve1(input: &str) -> usize {
-    let mut ans = 0;
-    let grid = Grid::from_str(input, |c| c);
-    let mut pos = grid.positions(&'S');
-    pos[0].0 += 1;
-    let tachyons = grid.positions(&'^');
-    let empty_spaces = grid.positions(&'.');
-
-    while !pos.is_empty() {
-        let cnt_empty_spaces: Vec<CellIndex> = empty_spaces
-            .iter()
-            .filter(|x| pos.contains(x))
-            .map(|x| *x)
-            .collect();
-        let cnt: Vec<CellIndex> = tachyons
-            .iter()
-            .filter(|x| pos.contains(x))
-            .map(|x| *x)
-            .collect();
-        let mut new_pos = HashSet::new();
-
-        for c in &cnt_empty_spaces {
-            new_pos.insert((c.0 + 1, c.1));
-        }
-
-        for c in &cnt {
-            if c.1 > 0 {
-                new_pos.insert((c.0 + 1, c.1 - 1));
-            }
-            if c.1 + 1 < grid.cols {
-                new_pos.insert((c.0 + 1, c.1 + 1));
-            }
-        }
-        pos = new_pos.into_iter().collect::<Vec<CellIndex>>();
-        ans += cnt.len();
-    }
-
-    //grid.print();
-    ans
+    (ans1, ans2)
 }
 
 fn main() {
     if let Some(input) = common::get_input() {
-        common::timed(&input, solve1, true);
-        common::timed(&input, solve2, false);
+        common::timed(&input, solve, true);
     }
 }
 
@@ -115,7 +67,6 @@ mod tests {
     #[test]
     fn test_samples() {
         let sample_input = ".......S.......\n...............\n.......^.......\n...............\n......^.^......\n...............\n.....^.^.^.....\n...............\n....^.^...^....\n...............\n...^.^...^.^...\n...............\n..^...^.....^..\n...............\n.^.^.^.^.^...^.\n...............";
-        assert_eq!(solve1(sample_input), 21);
-        assert_eq!(solve2(sample_input), 40);
+        assert_eq!(solve(sample_input), (21, 40));
     }
 }

src/common.rs

@@ -40,6 +40,23 @@ impl<K: Copy + Hash + Eq + PartialEq, V, S: BuildHasher> HashMapVector<K, V>
     }
 }
 
+pub trait HashMapCount<K: Copy + Hash + Eq + PartialEq> {
+    fn insert_with_count(&mut self, key: &K, value: usize);
+}
+
+impl<K: Copy + Hash + Eq + PartialEq> HashMapCount<K> for HashMap<K, usize> {
+    fn insert_with_count(&mut self, key: &K, value: usize) {
+        match self.get_mut(key) {
+            Some(vals) => {
+                *vals += value;
+            }
+            None => {
+                self.insert(*key, value);
+            }
+        }
+    }
+}
+
 pub fn minmax<T: Ord + Copy>(x: &T, y: &T) -> (T, T) {
     (*x.min(y), *x.max(y))
 }