Add problem 2283: Minimum Hours of Training to Win a Competition

Author: EFanZh

src/lib.rs

@@ -1773,6 +1773,7 @@ pub mod problem_2379_minimum_recolors_to_get_k_consecutive_black_blocks;
 pub mod problem_2380_time_needed_to_rearrange_a_binary_string;
 pub mod problem_2381_shifting_letters_ii;
 pub mod problem_2382_maximum_segment_sum_after_removals;
+pub mod problem_2383_minimum_hours_of_training_to_win_a_competition;
 
 #[cfg(test)]
 mod test_utilities;

src/problem_2383_minimum_hours_of_training_to_win_a_competition/iterative.rs

@@ -0,0 +1,59 @@
+pub struct Solution;
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+use std::iter;
+
+impl Solution {
+    pub fn min_number_of_hours(
+        initial_energy: i32,
+        initial_experience: i32,
+        energy: Vec<i32>,
+        experience: Vec<i32>,
+    ) -> i32 {
+        let mut current_energy = initial_energy as u32;
+        let mut current_experience = initial_experience as u32;
+        let mut result = 0;
+
+        iter::zip(&energy, &experience).for_each(|(&required_energy, &required_experience)| {
+            let (required_energy, required_experience) = (required_energy as u32, required_experience as u32);
+
+            if current_energy <= required_energy {
+                result += required_energy + 1 - current_energy;
+                current_energy = 1;
+            } else {
+                current_energy -= required_energy;
+            }
+
+            if current_experience <= required_experience {
+                result += required_experience + 1 - current_experience;
+                current_experience = required_experience + 1;
+            }
+
+            current_experience += required_experience;
+        });
+
+        result as _
+    }
+}
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl super::Solution for Solution {
+    fn min_number_of_hours(
+        initial_energy: i32,
+        initial_experience: i32,
+        energy: Vec<i32>,
+        experience: Vec<i32>,
+    ) -> i32 {
+        Self::min_number_of_hours(initial_energy, initial_experience, energy, experience)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_solution() {
+        super::super::tests::run::<super::Solution>();
+    }
+}

src/problem_2383_minimum_hours_of_training_to_win_a_competition/mod.rs

@@ -0,0 +1,25 @@
+pub mod iterative;
+
+pub trait Solution {
+    fn min_number_of_hours(initial_energy: i32, initial_experience: i32, energy: Vec<i32>, experience: Vec<i32>)
+        -> i32;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    pub fn run<S: Solution>() {
+        let test_cases = [
+            ((5, 3, &[1, 4, 3, 2] as &[_], &[2, 6, 3, 1] as &[_]), 8),
+            ((2, 4, &[1], &[3]), 0),
+        ];
+
+        for ((initial_energy, initial_experience, energy, experience), expected) in test_cases {
+            assert_eq!(
+                S::min_number_of_hours(initial_energy, initial_experience, energy.to_vec(), experience.to_vec()),
+                expected
+            );
+        }
+    }
+}