Fix Clippy warnings

Author: EFanZh

src/problem_0004_median_of_two_sorted_arrays/binary_search.rs

@@ -40,7 +40,7 @@ impl Solution {
                 nums2.get(other.wrapping_sub(1)).copied().unwrap_or(i32::MIN),
             ));
 
-            (left_max + right_min) / 2.0
+            f64::midpoint(left_max, right_min)
         } else {
             right_min
         }

src/problem_0069_sqrtx/binary_search.rs

@@ -11,7 +11,7 @@ impl Solution {
         let mut right = x.min(46340) + 1;
 
         while right - left > 1 {
-            let middle = (left + right) / 2;
+            let middle = u32::midpoint(left, right);
 
             match (middle * middle).cmp(&x) {
                 Ordering::Less => left = middle,

src/problem_0069_sqrtx/newtons_method.rs

@@ -10,7 +10,7 @@ impl Solution {
         let mut guess = x.min(46340);
 
         while guess * guess > x {
-            guess = (guess + x / guess) / 2;
+            guess = u32::midpoint(guess, x / guess);
         }
 
         guess as _

src/problem_0069_sqrtx/newtons_method_with_f32.rs

@@ -10,13 +10,13 @@ impl Solution {
         let mut guess = f32::from_bits((x as f32).to_bits() / 2 + 0x1FC0_0000) as u32;
 
         if guess * guess > x {
-            guess = (guess + x / guess) / 2;
+            guess = u32::midpoint(guess, x / guess);
 
             if guess * guess > x {
-                guess = (guess + x / guess) / 2;
+                guess = u32::midpoint(guess, x / guess);
 
                 if guess * guess > x {
-                    guess = (guess + x / guess) / 2;
+                    guess = u32::midpoint(guess, x / guess);
                 }
             }
         }

src/problem_0069_sqrtx/newtons_method_with_f64.rs

@@ -8,13 +8,13 @@ impl Solution {
         let mut guess = f64::from_bits(f64::from(x).to_bits() / 2 + 0x1FF8_0000_0000_0000) as u32;
 
         if guess * guess > x {
-            guess = (guess + x / guess) / 2;
+            guess = u32::midpoint(guess, x / guess);
 
             if guess * guess > x {
-                guess = (guess + x / guess) / 2;
+                guess = u32::midpoint(guess, x / guess);
 
                 if guess * guess > x {
-                    guess = (guess + x / guess) / 2;
+                    guess = u32::midpoint(guess, x / guess);
                 }
             }
         }

src/problem_0069_sqrtx/smart_newtons_method.rs

@@ -8,7 +8,7 @@ impl Solution {
         let mut guess = (1 << ((33 - x.leading_zeros()) / 2)) - 1;
 
         while guess * guess > x {
-            guess = (guess + x / guess) / 2;
+            guess = u32::midpoint(guess, x / guess);
         }
 
         guess as _

src/problem_0069_sqrtx/smarter_newtons_method.rs

@@ -8,19 +8,19 @@ impl Solution {
         let mut guess = (1 << ((33 - x.leading_zeros()) / 2)) - 1;
 
         if guess * guess > x {
-            guess = (guess + x / guess) / 2;
+            guess = u32::midpoint(guess, x / guess);
 
             if guess * guess > x {
-                guess = (guess + x / guess) / 2;
+                guess = u32::midpoint(guess, x / guess);
 
                 if guess * guess > x {
-                    guess = (guess + x / guess) / 2;
+                    guess = u32::midpoint(guess, x / guess);
 
                     if guess * guess > x {
-                        guess = (guess + x / guess) / 2;
+                        guess = u32::midpoint(guess, x / guess);
 
                         if guess * guess > x {
-                            guess = (guess + x / guess) / 2;
+                            guess = u32::midpoint(guess, x / guess);
                         }
                     }
                 }

src/problem_0073_set_matrix_zeroes/two_passes.rs

@@ -10,7 +10,7 @@ impl Solution {
                     (true, true)
                 } else {
                     (
-                        first_row_rest_cells.iter().any(|x| *x == 0),
+                        first_row_rest_cells.contains(&0),
                         rest_rows.iter().any(|row| row[0] == 0),
                     )
                 };

src/problem_0073_set_matrix_zeroes/two_passes_2.rs

@@ -6,7 +6,7 @@ impl Solution {
     #[expect(clippy::ptr_arg, reason = "required")]
     pub fn set_zeroes(matrix: &mut Vec<Vec<i32>>) {
         if let Some((first_row, rest_rows)) = matrix.split_first_mut() {
-            let first_row_has_zero = first_row.iter().any(|x| *x == 0);
+            let first_row_has_zero = first_row.contains(&0);
 
             for row in &mut *rest_rows {
                 let mut iter = row.iter_mut().zip(first_row.iter_mut());

src/problem_0083_remove_duplicates_from_sorted_list/iterative.rs

@@ -5,6 +5,7 @@ pub struct Solution;
 // ------------------------------------------------------ snip ------------------------------------------------------ //
 
 impl Solution {
+    #[expect(clippy::single_option_map, reason = "required")]
     pub fn delete_duplicates(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
         head.map(|mut node| {
             let mut tail = node.as_mut();

src/problem_0083_remove_duplicates_from_sorted_list/recursive.rs

@@ -17,6 +17,7 @@ impl Solution {
         }
     }
 
+    #[expect(clippy::single_option_map, reason = "required")]
     pub fn delete_duplicates(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
         head.map(|mut node| {
             let next = node.next.take();

src/problem_0135_candy/tail_recursive.rs

@@ -10,7 +10,7 @@ impl Solution {
     }
 
     fn triangular_2(x: i32, y: i32) -> i32 {
-        (x * (x + 1) + y * (y + 1)) / 2
+        i32::midpoint(x * (x + 1), y * (y + 1))
     }
 
     fn going_down(first: i32, rest: &[i32], up_length: i32, down_length: i32, result: &mut i32) {

src/problem_0235_lowest_common_ancestor_of_a_binary_search_tree/iterative.rs

@@ -9,6 +9,7 @@ use std::mem;
 use std::rc::Rc;
 
 impl Solution {
+    #[expect(clippy::single_option_map, reason = "required")]
     pub fn lowest_common_ancestor(
         root: Option<Rc<RefCell<TreeNode>>>,
         p: Option<Rc<RefCell<TreeNode>>>,

src/problem_0235_lowest_common_ancestor_of_a_binary_search_tree/recursive.rs

@@ -20,6 +20,7 @@ impl Solution {
         }
     }
 
+    #[expect(clippy::single_option_map, reason = "required")]
     pub fn lowest_common_ancestor(
         root: Option<Rc<RefCell<TreeNode>>>,
         p: Option<Rc<RefCell<TreeNode>>>,

src/problem_0236_lowest_common_ancestor_of_a_binary_tree/mod.rs

@@ -81,7 +81,7 @@ mod tests {
 
         for ((root, p, q), expected) in test_cases {
             let root = test_utilities::make_tree(root.iter().copied());
-            let inverted_root = test_utilities::invert_tree(root.as_deref());
+            let inverted_root = root.as_deref().map(test_utilities::invert_tree);
 
             for (root, p, q) in [
                 (root.clone(), p, q),

src/problem_0236_lowest_common_ancestor_of_a_binary_tree/recursive.rs

@@ -78,6 +78,7 @@ impl Solution {
         }
     }
 
+    #[expect(clippy::single_option_map, reason = "required")]
     pub fn lowest_common_ancestor(
         root: Option<Rc<RefCell<TreeNode>>>,
         p: Option<Rc<RefCell<TreeNode>>>,

src/problem_0367_valid_perfect_square/binary_search.rs

@@ -10,7 +10,7 @@ impl Solution {
         let mut right = num.min(46340);
 
         while left != right {
-            let middle = (left + right) / 2;
+            let middle = i32::midpoint(left, right);
 
             match (middle * middle).cmp(&num) {
                 Ordering::Less => left = middle + 1,

src/problem_0367_valid_perfect_square/newtons_method.rs

@@ -13,7 +13,7 @@ impl Solution {
             match (x * x).cmp(&num) {
                 Ordering::Less => return false,
                 Ordering::Equal => return true,
-                Ordering::Greater => x = (x + num / x) / 2,
+                Ordering::Greater => x = u64::midpoint(x, num / x),
             }
         }
     }

src/problem_0410_split_array_largest_sum/binary_search.rs

@@ -37,7 +37,7 @@ impl Solution {
         let mut right = sum;
 
         while left != right {
-            let middle = (left + right) / 2;
+            let middle = i32::midpoint(left, right);
 
             if Self::helper(&nums, m, middle) {
                 right = middle;

src/problem_0475_heaters/iterative.rs

@@ -16,7 +16,7 @@ impl Solution {
         for (heater, boundary) in heaters
             .iter()
             .zip(&heaters[1..])
-            .map(|(&left, &right)| (left, (left + right) / 2))
+            .map(|(&left, &right)| (left, i32::midpoint(left, right)))
         {
             while house <= boundary {
                 result = result.max((house - heater).abs());

src/problem_0480_sliding_window_median/two_binary_heaps.rs

@@ -78,7 +78,10 @@ impl Solution {
 
         if k % 2 == 0 {
             Self::helper(window, &nums, |window| {
-                (f64::from(window.0.peek().unwrap().0) + f64::from(window.1.peek().unwrap().0.0)) / 2.0
+                f64::midpoint(
+                    f64::from(window.0.peek().unwrap().0),
+                    f64::from(window.1.peek().unwrap().0.0),
+                )
             })
         } else {
             Self::helper(window, &nums, |window| f64::from(window.1.peek().unwrap().0.0))

src/problem_0480_sliding_window_median/two_sets.rs

@@ -105,7 +105,10 @@ impl Window {
 
     fn get_median(&self) -> f64 {
         if self.left.len() == self.right.len() {
-            (f64::from(self.left.last().unwrap()) + f64::from(self.right.first().unwrap())) / 2.0
+            f64::midpoint(
+                f64::from(self.left.last().unwrap()),
+                f64::from(self.right.first().unwrap()),
+            )
         } else {
             f64::from(self.right.first().unwrap())
         }

src/problem_0540_single_element_in_a_sorted_array/binary_search.rs

@@ -8,7 +8,7 @@ impl Solution {
         let mut right = nums.len() - 1;
 
         while left != right {
-            let middle = ((left + right) / 2) & !1;
+            let middle = usize::midpoint(left, right) & !1;
 
             if nums[middle] == nums[middle + 1] {
                 left = middle + 2;

src/problem_0540_single_element_in_a_sorted_array/binary_search_2.rs

@@ -10,7 +10,7 @@ impl Solution {
         let mut right = nums.len() - 1;
 
         while left != right {
-            let middle = (left + right) / 2;
+            let middle = usize::midpoint(left, right);
 
             if nums[middle] == nums[middle ^ 1] {
                 left = middle + 1;

src/problem_0623_add_one_row_to_tree/mod.rs

@@ -55,8 +55,8 @@ mod tests {
         for ((root, val, depth), expected) in test_cases {
             let root = test_utilities::make_tree(root.iter().copied());
             let expected = test_utilities::make_tree(expected.iter().copied());
-            let inverted_root = test_utilities::invert_tree(root.as_deref());
-            let inverted_expected = test_utilities::invert_tree(expected.as_deref());
+            let inverted_root = root.as_deref().map(test_utilities::invert_tree);
+            let inverted_expected = expected.as_deref().map(test_utilities::invert_tree);
 
             for (root, expected) in [(root, expected), (inverted_root, inverted_expected)] {
                 assert_eq!(S::add_one_row(root, val, depth), expected);

src/problem_0655_print_binary_tree/recursive.rs

@@ -19,7 +19,7 @@ impl Solution {
     }
 
     fn helper(node: &RefCell<TreeNode>, row: usize, start: usize, end: usize, result: &mut [Vec<String>]) {
-        let middle = (start + end) / 2;
+        let middle = usize::midpoint(start, end);
         let node = node.borrow();
 
         result[row][middle] = node.val.to_string();

src/problem_0668_kth_smallest_number_in_multiplication_table/binary_search.rs

@@ -28,7 +28,7 @@ impl Solution {
         let mut right = m * n;
 
         while left < right {
-            let middle = (left + right) / 2;
+            let middle = u32::midpoint(left, right);
 
             if Self::check(m, n, k, middle) {
                 left = middle + 1;

src/problem_0718_maximum_length_of_repeated_subarray/binary_search.rs

@@ -98,7 +98,7 @@ impl Solution {
         let mut bucket_pool = Vec::with_capacity(nums1.len());
 
         while left < right {
-            let middle = (left + right) / 2;
+            let middle = usize::midpoint(left, right);
 
             if Self::check(&nums1, &nums2, middle, &mut buckets_buffer, &mut bucket_pool) {
                 left = middle + 1;

src/problem_0719_find_k_th_smallest_pair_distance/binary_search.rs

@@ -28,7 +28,7 @@ impl Solution {
         let mut right = nums.last().unwrap() - nums.first().unwrap();
 
         while left < right {
-            let middle = (left + right) / 2;
+            let middle = i32::midpoint(left, right);
 
             if Self::check(&nums, middle, k) {
                 left = middle + 1;

src/problem_0793_preimage_size_of_factorial_zeroes_function/binary_search.rs

@@ -23,7 +23,7 @@ impl Solution {
         let mut right = k;
 
         while left < right {
-            let middle = (left + right) / 2;
+            let middle = u32::midpoint(left, right);
 
             match Self::f(middle).cmp(&k) {
                 Ordering::Less => left = middle + 1,

src/problem_0799_champagne_tower/dynamic_programming.rs

@@ -46,7 +46,7 @@ impl Solution {
             let query_glass = query_glass.min(query_row - query_glass);
             let left = cache.get(query_glass.wrapping_sub(1)).copied().unwrap_or(0.0);
             let right = cache[query_glass.min(cache.len() - 1)];
-            let incoming = (left + right) / 2.0;
+            let incoming = f64::midpoint(left, right);
 
             incoming.min(1.0)
         }

src/problem_0852_peak_index_in_a_mountain_array/binary_search.rs

@@ -8,7 +8,7 @@ impl Solution {
         let mut right = arr.len() - 2;
 
         while left < right {
-            let middle = (left + right) / 2;
+            let middle = usize::midpoint(left, right);
 
             if arr[middle] < arr[middle + 1] {
                 left = middle + 1;

src/problem_0855_exam_room/binary_heap.rs

@@ -18,7 +18,7 @@ impl Chunk {
         if self.start == 0 {
             0
         } else if self.end & 0x8000_0000 == 0 {
-            (self.start + self.end) / 2
+            u32::midpoint(self.start, self.end)
         } else {
             self.end()
         }

src/problem_0875_koko_eating_bananas/binary_search.rs

@@ -29,7 +29,7 @@ impl Solution {
         let mut high = max;
 
         while low < high {
-            let middle = (low + high) / 2;
+            let middle = u32::midpoint(low, high);
 
             if Self::check(&piles, h, middle) {
                 low = middle + 1;

src/problem_0878_nth_magical_number/binary_search.rs

@@ -38,7 +38,7 @@ impl Solution {
         let mut high = Self::mul_sub_div(top, n + 2, 1, base);
 
         while low < high {
-            let middle = (low + high) / 2;
+            let middle = u64::midpoint(low, high);
 
             if middle / a + middle / b - middle / lcm < n {
                 low = middle + 1;

src/problem_0878_nth_magical_number/mathematical.rs

@@ -31,7 +31,7 @@ impl Solution {
         let mut high = ((a_u64 * b_u64 * (n_u64 + 2) - 1) / (a_u64 + b_u64)) as u32;
 
         while low < high {
-            let middle = (low + high) / 2;
+            let middle = u32::midpoint(low, high);
 
             if middle / a + middle / b < n {
                 low = middle + 1;

src/problem_0887_super_egg_drop/binary_search.rs

@@ -41,7 +41,7 @@ impl Solution {
             let mut high = n;
 
             while low < high {
-                let middle = (low + high) / 2;
+                let middle = u32::midpoint(low, high);
 
                 if Self::check_moves(k, middle, n) {
                     high = middle;

src/problem_1011_capacity_to_ship_packages_within_d_days/binary_search.rs

@@ -44,7 +44,7 @@ impl Solution {
         let mut right = total;
 
         while left < right {
-            let middle = (left + right) / 2;
+            let middle = u32::midpoint(left, right);
 
             if Self::check(weights, days, middle) {
                 right = middle;

src/problem_1044_longest_duplicate_substring/binary_search_and_rolling_hash.rs

@@ -120,7 +120,7 @@ impl Solution {
         let mut length = 0;
 
         while left < right {
-            let middle = (left + right) / 2;
+            let middle = usize::midpoint(left, right);
 
             if let Some(i) = Self::helper::<91_320_515_216_383_913>(s.as_bytes(), middle, &mut buckets, &mut pool) {
                 start = i;