Move over to using enum

day_07/src/equation.rs

@@ -1,12 +1,6 @@
 mod operator_set;
 
-use operator_set::create_operator_set;
+use operator_set::{Op, create_operator_set};
-
-#[derive(Debug, Clone, Copy)]
-enum Ops {
-    Multiply,
-    Add,
-}
 
 #[derive(Debug)]
 pub struct Equation {
@@ -56,16 +50,13 @@ impl Equation {
         &self.components
     }
 
-    fn compute_answer(&self, operators: &[bool]) -> i64 {
+    fn compute_answer(&self, operators: &[Op]) -> i64 {
         let mut accumulator = self.components[0];
 
-        for (i, op_bool) in operators.iter().enumerate() {
+        for (i, op) in operators.iter().enumerate() {
-            if *op_bool {
+            match op {
-                // Multiply
+                Op::Multiply => accumulator *= self.components[i + 1],
-                accumulator *= self.components[i + 1];
+                Op::Add => accumulator += self.components[i + 1],
-            } else {
-                // Add
-                accumulator += self.components[i + 1];
             }
         }
 

day_07/src/equation/operator_set.rs

@@ -2,16 +2,22 @@ use std::collections::HashMap;
 use std::collections::HashSet;
 use std::sync::{LazyLock, Mutex};
 
-type OperatorCache = HashMap<usize, HashSet<Vec<bool>>>;
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
+pub enum Op {
+    Multiply,
+    Add,
+}
+
+type OperatorCache = HashMap<usize, HashSet<Vec<Op>>>;
 
 static OPERATOR_SET_CACHE: LazyLock<Mutex<OperatorCache>> =
     LazyLock::new(|| Mutex::new(HashMap::new()));
 
-fn check_operator_set_cache(cache_key: usize) -> Option<HashSet<Vec<bool>>> {
+fn check_operator_set_cache(cache_key: usize) -> Option<HashSet<Vec<Op>>> {
     OPERATOR_SET_CACHE.lock().unwrap().get(&cache_key).cloned()
 }
 
-fn store_operator_set_in_cache(cache_key: usize, cache_value: HashSet<Vec<bool>>) {
+fn store_operator_set_in_cache(cache_key: usize, cache_value: HashSet<Vec<Op>>) {
     OPERATOR_SET_CACHE
         .lock()
         .unwrap()
@@ -19,32 +25,32 @@ fn store_operator_set_in_cache(cache_key: usize, cache_value: HashSet<Vec<bool>>
 }
 
 fn create_operator_set_recurse(
-    operators_permutation_set: &mut HashSet<Vec<bool>>,
+    operators_permutation_set: &mut HashSet<Vec<Op>>,
-    operators: Vec<bool>,
+    operators: Vec<Op>,
 ) {
     operators_permutation_set.insert(operators.clone());
-    if !operators.contains(&false) {
+    if !operators.contains(&Op::Add) {
         return;
     }
 
     for i in 0..operators.len() {
-        if operators[i] {
+        if operators[i] == Op::Multiply {
-            continue;
+            break;
         }
         let mut new_operators = operators.clone();
-        new_operators[i] = true;
+        new_operators[i] = Op::Multiply;
         create_operator_set_recurse(operators_permutation_set, new_operators);
     }
 }
 
-pub fn create_operator_set(num_of_operators: usize) -> HashSet<Vec<bool>> {
+pub fn create_operator_set(num_of_operators: usize) -> HashSet<Vec<Op>> {
     // Check cache
     if let Some(cached_value) = check_operator_set_cache(num_of_operators) {
         return cached_value.clone();
     }
 
-    let mut operator_sets: HashSet<Vec<bool>> = HashSet::new();
+    let mut operator_sets: HashSet<Vec<Op>> = HashSet::new();
-    create_operator_set_recurse(&mut operator_sets, vec![false; num_of_operators]);
+    create_operator_set_recurse(&mut operator_sets, vec![Op::Add; num_of_operators]);
 
     // Store value in cache
     store_operator_set_in_cache(num_of_operators, operator_sets.clone());