Use Arc to not clone cached permutations

day_07/src/equation.rs

@@ -1,5 +1,7 @@
 mod operator_set;
 
+use std::ops::Deref;
+
 use operator_set::{Op, create_permutations};
 
 #[derive(Debug)]
@@ -69,8 +71,8 @@ impl Equation {
         let op_combinations =
             create_permutations(&Equation::MULTIPLY_ADD_SET, self.components.len() - 1);
 
-        for combination in op_combinations {
-            if self.answer == self.compute_answer(&combination) {
+        for combination in op_combinations.deref() {
+            if self.answer == self.compute_answer(combination) {
                 return true;
             }
         }
@@ -84,8 +86,8 @@ impl Equation {
             self.components.len() - 1,
         );
 
-        for combination in op_combinations {
-            if self.answer == self.compute_answer(&combination) {
+        for combination in op_combinations.deref() {
+            if self.answer == self.compute_answer(combination) {
                 return true;
             }
         }

day_07/src/equation/operator_set.rs

@@ -22,17 +22,21 @@ impl PermutationCacheKey {
 }
 
 type Permutation = Vec<Op>;
-
-type OperatorCache = HashMap<PermutationCacheKey, HashSet<Permutation>>;
+type OperatorCache = HashMap<PermutationCacheKey, Arc<HashSet<Permutation>>>;
 
 static OPERATOR_SET_CACHE: LazyLock<Mutex<OperatorCache>> =
     LazyLock::new(|| Mutex::new(HashMap::new()));
 
-fn check_operator_set_cache(cache_key: &PermutationCacheKey) -> Option<HashSet<Permutation>> {
-    OPERATOR_SET_CACHE.lock().unwrap().get(cache_key).cloned()
+fn check_operator_set_cache(cache_key: &PermutationCacheKey) -> Option<Arc<HashSet<Permutation>>> {
+    let lock = OPERATOR_SET_CACHE.lock().unwrap();
+    let cache_value = lock.get(cache_key);
+    cache_value.cloned()
 }
 
-fn store_operator_set_in_cache(cache_key: PermutationCacheKey, cache_value: HashSet<Permutation>) {
+fn store_operator_set_in_cache(
+    cache_key: PermutationCacheKey,
+    cache_value: Arc<HashSet<Permutation>>,
+) {
     OPERATOR_SET_CACHE
         .lock()
         .unwrap()
@@ -57,13 +61,19 @@ fn create_permutations_recurse(
     }
 }
 
-pub fn create_permutations(set: &[Op], len: usize) -> HashSet<Permutation> {
+pub fn create_permutations(set: &[Op], len: usize) -> Arc<HashSet<Permutation>> {
+    // Check cache
     let cache_key = PermutationCacheKey::new(len, set.to_vec());
     if let Some(cached_value) = check_operator_set_cache(&cache_key) {
         return cached_value;
     }
+
+    // Create permutations
     let mut permutations = HashSet::new();
     create_permutations_recurse(set, len, &mut permutations, vec![]);
+
+    // Cache and return
+    let permutations = Arc::new(permutations);
     store_operator_set_in_cache(cache_key, permutations.clone());
     permutations
 }