84 lines
2.3 KiB
Rust
84 lines
2.3 KiB
Rust
use std::collections::HashMap;
|
|
use std::collections::HashSet;
|
|
use std::sync::{LazyLock, Mutex};
|
|
|
|
#[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<Op>>> {
|
|
OPERATOR_SET_CACHE.lock().unwrap().get(&cache_key).cloned()
|
|
}
|
|
|
|
fn store_operator_set_in_cache(cache_key: usize, cache_value: HashSet<Vec<Op>>) {
|
|
OPERATOR_SET_CACHE
|
|
.lock()
|
|
.unwrap()
|
|
.insert(cache_key, cache_value);
|
|
}
|
|
|
|
fn create_operator_set_recurse(
|
|
operators_permutation_set: &mut HashSet<Vec<Op>>,
|
|
operators: Vec<Op>,
|
|
) {
|
|
operators_permutation_set.insert(operators.clone());
|
|
if !operators.contains(&Op::Add) {
|
|
return;
|
|
}
|
|
|
|
for i in 0..operators.len() {
|
|
if operators[i] == Op::Multiply {
|
|
break;
|
|
}
|
|
let mut new_operators = operators.clone();
|
|
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<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<Op>> = HashSet::new();
|
|
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());
|
|
|
|
operator_sets
|
|
}
|
|
|
|
fn create_permutations_recurse(
|
|
values: &HashSet<Op>,
|
|
len: usize,
|
|
permutations: &mut HashSet<Vec<Op>>,
|
|
curr_permutation: Vec<Op>,
|
|
) {
|
|
if curr_permutation.len() == len {
|
|
permutations.insert(curr_permutation);
|
|
return;
|
|
}
|
|
|
|
for v in values {
|
|
let mut next_permutation = curr_permutation.clone();
|
|
next_permutation.push(*v);
|
|
create_permutations_recurse(values, len, permutations, next_permutation);
|
|
}
|
|
}
|
|
|
|
pub fn create_permutations(set: HashSet<Op>, len: usize) -> HashSet<Vec<Op>> {
|
|
let mut permutations = HashSet::new();
|
|
create_permutations_recurse(&set, len, &mut permutations, vec![]);
|
|
permutations
|
|
}
|