Refactor

Author: EFanZh

src/problem_0330_patching_array/greedy.rs

@@ -10,7 +10,7 @@ impl Solution {
         let mut iter = nums.into_iter();
 
         while max <= n {
-            if let Some(num) = iter.next().map(|x| x as u32) {
+            if let Some(num) = iter.next().map(i32::cast_unsigned) {
                 while num > max {
                     max *= 2;
                     result += 1;

src/problem_0372_super_pow/iterative.rs

@@ -23,8 +23,8 @@ impl Solution {
         let a = a as u32 % M;
         let mut result = 1;
 
-        for digit in b.into_iter().map(|d| d as _) {
-            result = (Self::pow_mod(result, 10, M) * Self::pow_mod(a, digit, M)) % M;
+        for digit in b {
+            result = (Self::pow_mod(result, 10, M) * Self::pow_mod(a, digit.cast_unsigned(), M)) % M;
         }
 
         result as _

src/problem_0372_super_pow/iterative_2.rs

@@ -24,8 +24,8 @@ impl Solution {
         let a = a as u32 % M;
         let mut result = 1;
 
-        for digit in b.into_iter().map(|d| d as _) {
-            result = (Self::pow_mod(result, 10, M) * Self::pow_mod(a, digit, M)) % M;
+        for digit in b {
+            result = (Self::pow_mod(result, 10, M) * Self::pow_mod(a, digit.cast_unsigned(), M)) % M;
         }
 
         result as _

src/problem_0911_online_election/precompute.rs

@@ -7,7 +7,7 @@ pub struct TopVotedCandidate {
 impl TopVotedCandidate {
     fn new(persons: Vec<i32>, times: Vec<i32>) -> Self {
         let n = persons.len();
-        let mut iter = times.into_iter().map(|time| time as u32).zip(persons);
+        let mut iter = times.into_iter().map(i32::cast_unsigned).zip(persons);
         let mut leads = Vec::with_capacity(n);
         let mut counts = vec![0_u32; n];
         let (first_time, first_person) = iter.next().unwrap();

src/problem_1223_dice_roll_simulation/dynamic_programming.rs

@@ -17,7 +17,7 @@ impl Solution {
 
     pub fn die_simulator(n: i32, roll_max: Vec<i32>) -> i32 {
         let n = n as usize;
-        let roll_max = <[_; 6]>::try_from(roll_max).ok().unwrap().map(|value| value as u32);
+        let roll_max = <[_; 6]>::try_from(roll_max).ok().unwrap().map(i32::cast_unsigned);
         let mut cache = vec![([0_u32; 6], 1_u32); n + 1];
         let mut prev = &cache[0];
 

src/problem_1250_check_if_it_is_a_good_array/iterative.rs

@@ -15,7 +15,7 @@ impl Solution {
     }
 
     pub fn is_good_array(nums: Vec<i32>) -> bool {
-        let mut iter = nums.into_iter().map(|num| num as u32);
+        let mut iter = nums.into_iter().map(i32::cast_unsigned);
         let mut gcd = iter.next().unwrap();
 
         for num in iter {

src/problem_1262_greatest_sum_divisible_by_three/dynamic_programming_2.rs

@@ -4,7 +4,7 @@ pub struct Solution;
 
 impl Solution {
     pub fn max_sum_div_three(nums: Vec<i32>) -> i32 {
-        let mut iter = nums.into_iter().map(|num| num as u32);
+        let mut iter = nums.into_iter().map(i32::cast_unsigned);
         let mut max_0 = 0;
 
         let (mut max_1, mut max_2) = 'outer: loop {

src/problem_1262_greatest_sum_divisible_by_three/dynamic_programming_3.rs

@@ -4,7 +4,7 @@ pub struct Solution;
 
 impl Solution {
     pub fn max_sum_div_three(nums: Vec<i32>) -> i32 {
-        let mut iter = nums.into_iter().map(|num| num as u32);
+        let mut iter = nums.into_iter().map(i32::cast_unsigned);
         let mut max_0 = 0;
         let mut max_1;
         let mut max_2;

src/problem_1262_greatest_sum_divisible_by_three/dynamic_programming_4.rs

@@ -4,7 +4,7 @@ pub struct Solution;
 
 impl Solution {
     pub fn max_sum_div_three(nums: Vec<i32>) -> i32 {
-        let mut iter = nums.into_iter().map(|num| num as u32);
+        let mut iter = nums.into_iter().map(i32::cast_unsigned);
         let mut cache = (0, 0, 0);
 
         'outer: loop {

src/problem_1354_construct_target_array_with_multiple_sums/restore_original_state.rs

@@ -8,7 +8,7 @@ use std::num::NonZeroU32;
 impl Solution {
     pub fn is_possible(target: Vec<i32>) -> bool {
         let mut sum = target.iter().copied().sum::<i32>() as u32;
-        let mut queue = target.into_iter().map(|value| value as u32).collect::<BinaryHeap<_>>();
+        let mut queue = target.into_iter().map(i32::cast_unsigned).collect::<BinaryHeap<_>>();
 
         loop {
             let mut top = queue.peek_mut().unwrap();