Faster strategy for day 7

Author: prevostc

README.md

@@ -11,15 +11,15 @@ Solutions for [Advent of Code](https://adventofcode.com/) in [Rust](https://www.
 
 | Day | Part 1 | Part 2 |
 | :---: | :---: | :---:  |
-| [Day 1](./src/bin/01.rs) | `31.7µs` | `39.7µs` |
-| [Day 2](./src/bin/02.rs) | `46.5µs` | `67.4µs` |
-| [Day 3](./src/bin/03.rs) | `213.3µs` | `238.4µs` |
-| [Day 4](./src/bin/04.rs) | `148.6µs` | `33.1µs` |
-| [Day 5](./src/bin/05.rs) | `65.6µs` | `181.1µs` |
-| [Day 6](./src/bin/06.rs) | `44.6µs` | `12.3ms` |
-| [Day 7](./src/bin/07.rs) | `554.7µs` | `7.1ms` |
-
-**Total: 21.06ms**
+| [Day 1](./src/bin/01.rs) | `31.6µs` | `40.7µs` |
+| [Day 2](./src/bin/02.rs) | `47.2µs` | `68.6µs` |
+| [Day 3](./src/bin/03.rs) | `222.9µs` | `246.5µs` |
+| [Day 4](./src/bin/04.rs) | `145.9µs` | `33.2µs` |
+| [Day 5](./src/bin/05.rs) | `66.0µs` | `188.7µs` |
+| [Day 6](./src/bin/06.rs) | `44.8µs` | `11.1ms` |
+| [Day 7](./src/bin/07.rs) | `316.2µs` | `319.6µs` |
+
+**Total: 12.87ms**
 <!--- benchmarking table --->
 
 ---

src/bin/07.rs

@@ -1,4 +1,3 @@
-use heapless::Vec as HeaplessVec;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 advent_of_code::solution!(7);
 
@@ -25,58 +24,48 @@ impl EquationData {
 
     #[inline]
     fn has_valid_ops_combination(&self, available_ops: &[Op]) -> bool {
-        let needed_ops = self.values.len() - 1;
-        if needed_ops == 0 {
-            return self.values[0] == self.test_value;
-        }
-
-        const OPS_SIZE: usize = 16;
-        const STACK_SIZE: usize = 32;
-
-        let mut stack = HeaplessVec::<_, STACK_SIZE>::new();
-        stack
-            .push((self.values[0], HeaplessVec::<_, OPS_SIZE>::new()))
-            .unwrap();
+        // Stack will store (current_target, remaining_numbers_index);
+        let mut stack = vec![(self.test_value, self.values.len() - 1)];
 
-        while let Some((current_value, mut ops)) = stack.pop() {
-            if ops.len() == needed_ops {
-                if current_value == self.test_value {
+        while let Some((current_target, idx)) = stack.pop() {
+            // Base case - if we're at the first number
+            if idx == 0 {
+                if self.values[0] == current_target {
                     return true;
                 }
                 continue;
             }
 
-            let next_idx = ops.len() + 1;
-            let next_value = self.values[next_idx];
+            let n = self.values[idx];
 
-            // Try each available operation
             for &op in available_ops {
-                let new_value = match op {
-                    Op::Add => current_value + next_value,
-                    Op::Mul => current_value * next_value,
+                match op {
+                    Op::Add => {
+                        if current_target >= n {
+                            stack.push((current_target - n, idx - 1));
+                        }
+                    }
+                    Op::Mul => {
+                        if current_target % n == 0 {
+                            stack.push((current_target / n, idx - 1));
+                        }
+                    }
                     Op::Concat => {
                         let mut digit_count = 0;
-                        let mut n = next_value;
-                        while n > 0 {
+                        let mut temp = n;
+                        while temp > 0 {
                             digit_count += 1;
-                            n /= 10;
+                            temp /= 10;
                         }
-                        current_value * 10_u64.pow(digit_count) + next_value
-                    }
-                };
+                        let divisor = 10_u64.pow(digit_count);
 
-                // Skip if we've already exceeded the target
-                if new_value > self.test_value {
-                    continue;
+                        if current_target % divisor == n {
+                            stack.push((current_target / divisor, idx - 1));
+                        }
+                    }
                 }
-
-                // Create new ops vector and push to stack
-                ops.push(op).unwrap();
-                stack.push((new_value, ops.clone())).unwrap();
-                ops.pop();
             }
         }
-
         false
     }
 }