Add problem 3375: Minimum Operations to Make Array Values Equal to K

Author: EFanZh

src/lib.rs

@@ -2207,6 +2207,7 @@ pub mod problem_3364_minimum_positive_sum_subarray;
 pub mod problem_3365_rearrange_k_substrings_to_form_target_string;
 pub mod problem_3370_smallest_number_with_all_set_bits;
 pub mod problem_3371_identify_the_largest_outlier_in_an_array;
+pub mod problem_3375_minimum_operations_to_make_array_values_equal_to_k;
 
 #[cfg(test)]
 mod test_utilities;

src/problem_3375_minimum_operations_to_make_array_values_equal_to_k/bit_masks.rs

@@ -0,0 +1,39 @@
+pub struct Solution;
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+use std::cmp::Ordering;
+
+impl Solution {
+    pub fn min_operations(nums: Vec<i32>, k: i32) -> i32 {
+        let nums = nums.into_iter().map(i32::cast_unsigned).collect::<Vec<_>>();
+        let k = k.cast_unsigned();
+        let mut masks = [0_usize; 101_usize.div_ceil(usize::BITS as usize)];
+
+        for num in nums {
+            match num.cmp(&k) {
+                Ordering::Less => return -1,
+                Ordering::Equal => {}
+                Ordering::Greater => masks[(num / usize::BITS) as usize] |= 1 << (num % usize::BITS),
+            }
+        }
+
+        masks.iter().copied().map(usize::count_ones).sum::<u32>().cast_signed()
+    }
+}
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl super::Solution for Solution {
+    fn min_operations(nums: Vec<i32>, k: i32) -> i32 {
+        Self::min_operations(nums, k)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_solution() {
+        super::super::tests::run::<super::Solution>();
+    }
+}

src/problem_3375_minimum_operations_to_make_array_values_equal_to_k/mod.rs

@@ -0,0 +1,22 @@
+pub mod bit_masks;
+
+pub trait Solution {
+    fn min_operations(nums: Vec<i32>, k: i32) -> i32;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    pub fn run<S: Solution>() {
+        let test_cases = [
+            ((&[5, 2, 5, 4, 5] as &[_], 2), 2),
+            ((&[2, 1, 2], 2), -1),
+            ((&[9, 7, 5, 3], 1), 4),
+        ];
+
+        for ((nums, k), expected) in test_cases {
+            assert_eq!(S::min_operations(nums.to_vec(), k), expected);
+        }
+    }
+}