Apply cargo clippy --fix

martwz · martwz · commit 1bf1ee4faea7 · 2021-10-03T07:04:38.000-07:00
diff --git a/src/leetcode/challenge/can_partition_k_subsets.rs b/src/leetcode/challenge/can_partition_k_subsets.rs
@@ -8,7 +8,7 @@ impl Solution {
       }
       let target = sum / k;
       
-      nums.sort();
+      nums.sort_unstable();
       if nums[nums.len() - 1] > target {
           return false;
       }
diff --git a/src/leetcode/challenge/cherry_pickup.rs b/src/leetcode/challenge/cherry_pickup.rs
@@ -22,22 +22,20 @@ impl Solution {
                 return *memo.get(key).unwrap();
             }
 
-            let dd = dp(&grid, &n, i1 + 1, j1, i2 + 1, j2, memo);
-            let dr = dp(&grid, &n, i1 + 1, j1, i2, j2 + 1, memo);
-            let rd = dp(&grid, &n, i1, j1 + 1, i2 + 1, j2, memo);
-            let rr = dp(&grid, &n, i1, j1 + 1, i2, j2 + 1, memo);
+            let dd = dp(grid, n, i1 + 1, j1, i2 + 1, j2, memo);
+            let dr = dp(grid, n, i1 + 1, j1, i2, j2 + 1, memo);
+            let rd = dp(grid, n, i1, j1 + 1, i2 + 1, j2, memo);
+            let rr = dp(grid, n, i1, j1 + 1, i2, j2 + 1, memo);
 
             let comb = i32::max(dd, i32::max(dr, i32::max(rd, rr)));
 
             let out;
             if comb == -1 {
                 out = -1;
+            } else if i1 == i2 && j1 == j2 {
+                out = comb + grid[i1][j1];
             } else {
-                if i1 == i2 && j1 == j2 {
-                    out = comb + grid[i1][j1];
-                } else {
-                    out = comb + grid[i1][j1] + grid[i2][j2];
-                }
+                out = comb + grid[i1][j1] + grid[i2][j2];
             }
 
             memo.insert(*key, out);
diff --git a/src/leetcode/challenge/max_sub_array_len.rs b/src/leetcode/challenge/max_sub_array_len.rs
@@ -17,12 +17,10 @@ impl Solution {
                 max_length = max_length.max(i - j);
             }
 
-            if !sum_to_index_mapping.contains_key(&curr_sum) {
-                sum_to_index_mapping.insert(curr_sum, i);
-            }
+            sum_to_index_mapping.entry(curr_sum).or_insert(i);
         }
 
-        return max_length as i32;
+        max_length as i32
     }
 }
 
diff --git a/src/leetcode/challenge/num_unique_emails.rs b/src/leetcode/challenge/num_unique_emails.rs
@@ -9,7 +9,7 @@ impl Solution {
         for email in emails {
             let email: Vec<_> = email.split('@').collect();
             let mut vhost: String = email[0].to_string().replace(".", "");
-            if vhost.contains("+") {
+            if vhost.contains('+') {
                 vhost = vhost.split('+').next().unwrap().to_string();
             }
 
@@ -18,7 +18,7 @@ impl Solution {
             set.insert(format!("{}@{}", vhost, domain));
         }
 
-        return set.len() as i32;
+        set.len() as i32
     }
 }
 
diff --git a/src/leetcode/challenge/sort_array_by_parity_ii.rs b/src/leetcode/challenge/sort_array_by_parity_ii.rs
@@ -26,7 +26,7 @@ impl Solution {
             }
         }
 
-        return ans;
+        ans
     }
 }
 
diff --git a/src/leetcode/contest/biweekly_62.rs b/src/leetcode/contest/biweekly_62.rs
@@ -27,10 +27,8 @@ impl Solution2 {
         let mut ans = 0;
         for i in 0..nums.len() {
             for j in 0..nums.len() {
-                if i != j {
-                    if [nums[i].clone(), nums[j].clone()].concat() == target {
-                        ans += 1;
-                    }
+                if i != j && [nums[i].clone(), nums[j].clone()].concat() == target {
+                    ans += 1;
                 }
             }
         }
@@ -97,8 +95,8 @@ impl Solution4 {
         let mut part1 = 0;
         let mut part2 = nums.iter().sum::<i32>();
         for i in 0..nums.len() {
-            part1 = part1 + nums[i];
-            part2 = part2 - nums[i];
+            part1 += nums[i];
+            part2 -= nums[i];
 
             pre_calcs.push((part1, part2, i));
         }
diff --git a/src/leetcode/contest/weekly_261.rs b/src/leetcode/contest/weekly_261.rs
@@ -20,15 +20,13 @@ impl Solution1 {
         while r < n {
             if r - l < 2 {
                 r += 1;
+            } else if arr[l] == 1 {
+                arr[l] = 0;
+                arr[l + 1] = 0;
+                arr[l + 2] = 0;
+                moves += 1;
             } else {
-                if arr[l] == 1 {
-                    arr[l] = 0;
-                    arr[l + 1] = 0;
-                    arr[l + 2] = 0;
-                    moves += 1;
-                } else {
-                    l += 1;
-                }
+                l += 1;
             }
 
             if r == n && (arr[r - 1] == 1 || arr[r - 2] == 1 || arr[r - 3] == 1) {
@@ -44,7 +42,7 @@ impl Solution1 {
 // https://leetcode.com/problems/find-missing-observations/
 impl Solution2 {
     pub fn missing_rolls(rolls: Vec<i32>, mean: i32, n: i32) -> Vec<i32> {
-        if rolls.len() == 0 || n == 0 {
+        if rolls.is_empty() || n == 0 {
             return vec![];
         }
 
@@ -77,7 +75,7 @@ impl Solution2 {
                 }
             }
 
-            return missing_rolls;
+            missing_rolls
         } else {
             return vec![];
         }
diff --git a/src/leetcode/problem/get_number_of_backlog_orders.rs b/src/leetcode/problem/get_number_of_backlog_orders.rs
@@ -63,20 +63,18 @@ impl Solution {
                         buy_backlog.push(o.clone());
                         break;
                     }
-                } else {
-                    if !buy_backlog.is_empty() && buy_backlog.peek().unwrap().price >= o.price * -1 {
-                        let mut buy_order = buy_backlog.pop().unwrap();
-                        let amount = i32::min(buy_order.amount, o.amount);
-                        o.amount -= amount;
-                        buy_order.amount -= amount;
-
-                        if buy_order.amount > 0 {
-                            buy_backlog.push(buy_order);
-                        }
-                    } else {
-                        sell_backlog.push(o.clone());
-                        break;
+                } else if !buy_backlog.is_empty() && buy_backlog.peek().unwrap().price >= o.price * -1 {
+                    let mut buy_order = buy_backlog.pop().unwrap();
+                    let amount = i32::min(buy_order.amount, o.amount);
+                    o.amount -= amount;
+                    buy_order.amount -= amount;
+
+                    if buy_order.amount > 0 {
+                        buy_backlog.push(buy_order);
                     }
+                } else {
+                    sell_backlog.push(o.clone());
+                    break;
                 }
             }
         }
diff --git a/src/leetcode/top_interview/array_and_string/group_anagrams.rs b/src/leetcode/top_interview/array_and_string/group_anagrams.rs
@@ -9,7 +9,7 @@ impl Solution {
 
         for str in strs {
             let mut chars = str.chars().collect::<Vec<char>>();
-            chars.sort();
+            chars.sort_unstable();
             let key: String = chars.into_iter().collect();
             if let Some(v) = map.get_mut(&key) {
                 v.push(str);
@@ -21,7 +21,7 @@ impl Solution {
         for (_, v) in map {
             ans.push(v);
         }
-        return ans;
+        ans
     }
 }
 
diff --git a/src/leetcode/top_interview/array_and_string/increasing_triplet.rs b/src/leetcode/top_interview/array_and_string/increasing_triplet.rs
@@ -16,7 +16,7 @@ impl Solution {
             }
         }
 
-        return false;
+        false
     }
 }
 
diff --git a/src/leetcode/top_interview/array_and_string/longest_palindrome.rs b/src/leetcode/top_interview/array_and_string/longest_palindrome.rs
@@ -18,19 +18,17 @@ impl Solution {
         let mut max_len = 0;
         for end in 1..n {
             for start in 0..end {
-                if chars[start] == chars[end] {
-                    if end - start == 1 || dp[start + 1][end - 1] {
-                        dp[start][end] = true;
-                        if max_len < end - start + 1 {
-                            max_len = end - start + 1;
-                            ans = chars[start..=end].iter().collect::<String>();
-                        }
+                if chars[start] == chars[end] && (end - start == 1 || dp[start + 1][end - 1]) {
+                    dp[start][end] = true;
+                    if max_len < end - start + 1 {
+                        max_len = end - start + 1;
+                        ans = chars[start..=end].iter().collect::<String>();
                     }
                 }
             }
         }
 
-        return ans;
+        ans
     }
 }
 
diff --git a/src/leetcode/top_interview/dynamic_programming/can_jump.rs b/src/leetcode/top_interview/dynamic_programming/can_jump.rs
@@ -8,7 +8,7 @@ impl Solution {
         pos.push_back(0);
         let mut jumps = nums.clone();
 
-        while pos.len() > 0 && *pos.back().unwrap() < nums.len() - 1 {
+        while !pos.is_empty() && *pos.back().unwrap() < nums.len() - 1 {
             let mut p = *pos.back().unwrap();
             if jumps[p] == 0 && pos.len() > 1 {
                 pos.pop_back();
@@ -22,7 +22,7 @@ impl Solution {
             }
         }
 
-        return pos.len() > 0 && *pos.back().unwrap() >= nums.len() - 1;
+        return !pos.is_empty() && *pos.back().unwrap() >= nums.len() - 1;
     }
 }
 
diff --git a/src/leetcode/top_interview/others/majority_element.rs b/src/leetcode/top_interview/others/majority_element.rs
@@ -18,7 +18,7 @@ impl Solution {
             }
         }
 
-        return cand.unwrap();
+        cand.unwrap()
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ impl Solution {`
`8`	`8`	`}`
`9`	`9`	`let target = sum / k;`
`10`	`10`
`11`		`- nums.sort();`
	`11`	`+ nums.sort_unstable();`
`12`	`12`	`if nums[nums.len() - 1] > target {`
`13`	`13`	`return false;`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,12 +17,10 @@ impl Solution {`
`17`	`17`	`max_length = max_length.max(i - j);`
`18`	`18`	`}`
`19`	`19`
`20`		`- if !sum_to_index_mapping.contains_key(&curr_sum) {`
`21`		`- sum_to_index_mapping.insert(curr_sum, i);`
`22`		`- }`
	`20`	`+ sum_to_index_mapping.entry(curr_sum).or_insert(i);`
`23`	`21`	`}`
`24`	`22`
`25`		`- return max_length as i32;`
	`23`	`+ max_length as i32`
`26`	`24`	`}`
`27`	`25`	`}`
`28`	`26`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ impl Solution {`
`9`	`9`	`for email in emails {`
`10`	`10`	`let email: Vec<_> = email.split('@').collect();`
`11`	`11`	`let mut vhost: String = email[0].to_string().replace(".", "");`
`12`		`- if vhost.contains("+") {`
	`12`	`+ if vhost.contains('+') {`
`13`	`13`	`vhost = vhost.split('+').next().unwrap().to_string();`
`14`	`14`	`}`
`15`	`15`
`@@ -18,7 +18,7 @@ impl Solution {`
`18`	`18`	`set.insert(format!("{}@{}", vhost, domain));`
`19`	`19`	`}`
`20`	`20`
`21`		`- return set.len() as i32;`
	`21`	`+ set.len() as i32`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ impl Solution {`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
`29`		`- return ans;`
	`29`	`+ ans`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
Original file line number	Diff line number	Diff line change
`@@ -27,10 +27,8 @@ impl Solution2 {`
`27`	`27`	`let mut ans = 0;`
`28`	`28`	`for i in 0..nums.len() {`
`29`	`29`	`for j in 0..nums.len() {`
`30`		`- if i != j {`
`31`		`- if [nums[i].clone(), nums[j].clone()].concat() == target {`
`32`		`- ans += 1;`
`33`		`- }`
	`30`	`+ if i != j && [nums[i].clone(), nums[j].clone()].concat() == target {`
	`31`	`+ ans += 1;`
`34`	`32`	`}`
`35`	`33`	`}`
`36`	`34`	`}`
`@@ -97,8 +95,8 @@ impl Solution4 {`
`97`	`95`	`let mut part1 = 0;`
`98`	`96`	`let mut part2 = nums.iter().sum::<i32>();`
`99`	`97`	`for i in 0..nums.len() {`
`100`		`- part1 = part1 + nums[i];`
`101`		`- part2 = part2 - nums[i];`
	`98`	`+ part1 += nums[i];`
	`99`	`+ part2 -= nums[i];`
`102`	`100`
`103`	`101`	`pre_calcs.push((part1, part2, i));`
`104`	`102`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ impl Solution {`
`16`	`16`	`}`
`17`	`17`	`}`
`18`	`18`
`19`		`- return false;`
	`19`	`+ false`
`20`	`20`	`}`
`21`	`21`	`}`
`22`	`22`
Original file line number	Diff line number	Diff line change
`@@ -18,19 +18,17 @@ impl Solution {`
`18`	`18`	`let mut max_len = 0;`
`19`	`19`	`for end in 1..n {`
`20`	`20`	`for start in 0..end {`
`21`		`- if chars[start] == chars[end] {`
`22`		`- if end - start == 1 \|\| dp[start + 1][end - 1] {`
`23`		`- dp[start][end] = true;`
`24`		`- if max_len < end - start + 1 {`
`25`		`- max_len = end - start + 1;`
`26`		`- ans = chars[start..=end].iter().collect::<String>();`
`27`		`- }`
	`21`	`+ if chars[start] == chars[end] && (end - start == 1 \|\| dp[start + 1][end - 1]) {`
	`22`	`+ dp[start][end] = true;`
	`23`	`+ if max_len < end - start + 1 {`
	`24`	`+ max_len = end - start + 1;`
	`25`	`+ ans = chars[start..=end].iter().collect::<String>();`
`28`	`26`	`}`
`29`	`27`	`}`
`30`	`28`	`}`
`31`	`29`	`}`
`32`	`30`
`33`		`- return ans;`
	`31`	`+ ans`
`34`	`32`	`}`
`35`	`33`	`}`
`36`	`34`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ impl Solution {`
`8`	`8`	`pos.push_back(0);`
`9`	`9`	`let mut jumps = nums.clone();`
`10`	`10`
`11`		`- while pos.len() > 0 && *pos.back().unwrap() < nums.len() - 1 {`
	`11`	`+ while !pos.is_empty() && *pos.back().unwrap() < nums.len() - 1 {`
`12`	`12`	`let mut p = *pos.back().unwrap();`
`13`	`13`	`if jumps[p] == 0 && pos.len() > 1 {`
`14`	`14`	`pos.pop_back();`
`@@ -22,7 +22,7 @@ impl Solution {`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`		`- return pos.len() > 0 && *pos.back().unwrap() >= nums.len() - 1;`
	`25`	`+ return !pos.is_empty() && *pos.back().unwrap() >= nums.len() - 1;`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`