Fix clippy

Author: Spxg

src/lib.rs

@@ -104,6 +104,7 @@
 #![allow(
     missing_docs,
     trivial_casts,
+    clippy::needless_continue,
     clippy::cargo_common_metadata,
     clippy::cast_possible_truncation,
     clippy::cast_possible_wrap,

src/problem_0043_multiply_strings/fold.rs

@@ -13,8 +13,7 @@ impl Solution {
                 let mut acc_rev = acc.into_iter();
                 let mut carry = 0;
 
-                for ch in std::iter::repeat(0)
-                    .take(count)
+                for ch in std::iter::repeat_n(0, count)
                     .chain(num1.as_bytes().iter().rev().map(|x| x - b'0'))
                 {
                     let caculate = x * ch + acc_rev.next().unwrap_or_default() + carry;

src/problem_0068_text_justification/iterative.rs

@@ -24,9 +24,8 @@ impl Solution {
                     let base = space / slot;
                     let rest = space % slot;
 
-                    let mut iter = std::iter::repeat(base + 1)
-                        .take(rest)
-                        .chain(std::iter::repeat(base).take(slot - rest));
+                    let mut iter = std::iter::repeat_n(base + 1, rest)
+                        .chain(std::iter::repeat_n(base, slot - rest));
 
                     let mut part = String::with_capacity(max_width);
                     for s in &words[start..idx] {

src/problem_0095_unique_binary_search_trees_ii/recursive.rs

@@ -10,7 +10,7 @@ impl Solution {
         fn helper(start: i32, end: i32) -> Vec<Option<Rc<RefCell<TreeNode>>>> {
             if start == end {
                 return vec![None];
-            };
+            }
 
             let mut result = Vec::new();
             for val in start..end {

src/problem_0096_unique_binary_search_trees/recursive.rs

@@ -5,22 +5,22 @@ use std::collections::HashMap;
 impl Solution {
     pub fn num_trees(n: i32) -> i32 {
         fn helper(start: i32, end: i32, cache: &mut HashMap<i32, i32>) -> i32 {
-            if start == (start + end) / 2 {
+            if start == i32::midpoint(start, end) {
                 return 1;
-            };
+            }
             if let Some(cache) = cache.get(&(end - start)) {
                 return *cache;
             }
 
             let mut result = 0;
-            for val in start..(start + end) / 2 {
+            for val in start..i32::midpoint(start, end) {
                 let left_tree = helper(start, val, cache);
                 let right_tree = helper(val + 1, end, cache);
                 result += 2 * left_tree * right_tree;
             }
             if (start + end) % 2 != 0 {
-                result += helper(start, (start + end) / 2, cache)
-                    * helper((start + end) / 2 + 1, end, cache);
+                result += helper(start, i32::midpoint(start, end), cache)
+                    * helper(i32::midpoint(start, end) + 1, end, cache);
             }
             cache.insert(end - start, result);
 

src/problem_0098_validate_binary_search_tree/recursive.rs

@@ -9,10 +9,11 @@ impl Solution {
     pub fn is_valid_bst(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
         #[allow(clippy::ref_option)]
         fn helper(node: &Option<Rc<RefCell<TreeNode>>>, last: &mut Option<i32>) -> bool {
-            node.as_ref().map_or(true, |node| {
+            node.as_ref().is_none_or(|node| {
                 helper(&node.borrow().left, last)
-                    && std::mem::replace(last, Some(node.borrow().val))
-                        .map_or(true, |x| x < node.borrow().val)
+                    && last
+                        .replace(node.borrow().val)
+                        .is_none_or(|x| x < node.borrow().val)
                     && helper(&node.borrow().right, last)
             })
         }

src/problem_0101_symmetric_tree/recursive.rs

@@ -21,9 +21,7 @@ impl Solution {
                 _ => false,
             }
         }
-        root.map_or(true, |root| {
-            helper(&root.borrow().left, &root.borrow().right)
-        })
+        root.is_none_or(|root| helper(&root.borrow().left, &root.borrow().right))
     }
 }
 

src/problem_0162_find_peak_element/binary_search.rs

@@ -5,7 +5,7 @@ impl Solution {
         let (mut left, mut right) = (0, nums.len() - 1);
 
         while left < right {
-            let mid = (left + right) / 2;
+            let mid = usize::midpoint(left, right);
             if nums[mid] < nums[mid + 1] {
                 left = mid + 1;
             } else {

src/problem_0441_arranging_coins/math.rs

@@ -2,7 +2,7 @@ pub struct Solution;
 
 impl Solution {
     pub fn arrange_coins(n: i32) -> i32 {
-        ((-1.0 + 8.0f64.mul_add(f64::from(n), 1.0).sqrt()) / 2.0) as i32
+        f64::midpoint(-1.0, 8.0f64.mul_add(f64::from(n), 1.0).sqrt()) as i32
     }
 }
 

src/problem_0481_magical_string/queue.rs

@@ -15,7 +15,7 @@ impl Solution {
             }
             count += x;
             prev = 1 + i32::from(prev == 1);
-            queue.extend(std::iter::repeat(prev).take(x as usize));
+            queue.extend(std::iter::repeat_n(prev, x as usize));
             result += if count > n { 1 } else { x } * i32::from(prev == 1);
         }