chore: upgrade tool-chain to nightly-2025-09-01

Author: ben1009

.github/workflows/check.yml

@@ -12,7 +12,7 @@ concurrency:
 
 env:    
   CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
-  RUST_TOOLCHAIN: nightly-2025-07-01
+  RUST_TOOLCHAIN: nightly-2025-09-01
 
 name: Check
 jobs:

.github/workflows/test.yml

@@ -12,7 +12,7 @@ concurrency:
 
 env:    
   CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
-  RUST_TOOLCHAIN: nightly-2025-07-01
+  RUST_TOOLCHAIN: nightly-2025-09-01
 
 name: Test
 jobs:

Cargo.toml

@@ -2,7 +2,7 @@
 name = "leetcode-rust"
 version = "0.1.0"
 authors = ["ben1009"]
-edition = "2021"
+edition = "2024"
 
 [dependencies]
 dotenv = "0.15.0"

rust-toolchain

@@ -1,2 +1,2 @@
 [toolchain]
-channel = "nightly-2025-07-01"
+channel = "nightly-2025-09-01"

src/main.rs

@@ -168,10 +168,10 @@ fn get_initialized_ids(path: &str) -> Vec<u32> {
 
     let mut ret = vec![];
     for l in content.lines() {
-        if !l.trim().starts_with("//") {
-            if let Some(id) = id_pattern.captures(l) {
-                ret.push(id.get(1).unwrap().as_str().parse::<u32>().unwrap());
-            }
+        if !l.trim().starts_with("//")
+            && let Some(id) = id_pattern.captures(l)
+        {
+            ret.push(id.get(1).unwrap().as_str().parse::<u32>().unwrap());
         }
     }
 

src/problem/mod.rs

@@ -37,6 +37,7 @@ pub mod p0152_maximum_product_subarray;
 pub mod p0153_find_minimum_in_rotated_sorted_array;
 pub mod p0155_min_stack;
 pub mod p0165_compare_version_numbers;
+pub mod p0190_reverse_bits;
 pub mod p0202_happy_number;
 pub mod p0205_isomorphic_strings;
 pub mod p0243_shortest_word_distance;

src/problem/p0001_two_sum.rs

@@ -42,12 +42,13 @@ pub struct Solution {}
 
 impl Solution {
     pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
-        let mut map = HashMap::new();
-        for (i, &n) in nums.iter().enumerate() {
-            if let Some(&j) = map.get(&(target - n)) {
-                return vec![j, i as i32];
+        let mut dic = HashMap::new();
+        for (idx, &n) in nums.iter().enumerate() {
+            if let Some(&v) = dic.get(&(target - n)) {
+                return vec![v as i32, idx as i32];
             }
-            map.insert(n, i as i32);
+
+            dic.insert(n, idx);
         }
 
         vec![]
@@ -62,8 +63,10 @@ mod tests {
 
     #[test]
     fn test_1() {
-        assert!(Solution::two_sum(vec![2, 7, 11, 15], 9) == vec![0, 1]);
-        assert!(Solution::two_sum(vec![3, 2, 4], 6) == vec![1, 2]);
-        assert!(Solution::two_sum(vec![3, 3], 6) == vec![0, 1]);
+        assert_eq!(Solution::two_sum(vec![2, 7, 11, 15], 9), vec![0, 1]);
+        assert_eq!(Solution::two_sum(vec![3, 2, 4], 6), vec![1, 2]);
+        assert_eq!(Solution::two_sum(vec![3, 3], 6), vec![0, 1]);
+        assert_eq!(Solution::two_sum(vec![3, 2, 3], 6), vec![0, 2]);
+        assert_eq!(Solution::two_sum(vec![0, 4, 3, 0], 0), vec![0, 3]);
     }
 }

src/problem/p0002_add_two_numbers.rs

@@ -64,25 +64,25 @@ impl Solution {
             return l1;
         }
 
-        let mut root_pointer = ListNode::new(0);
-        let mut current = &mut root_pointer;
-        let mut carry = 0;
         let mut l1 = l1;
         let mut l2 = l2;
+        let mut carry = 0;
+        let mut root_pointer = ListNode::new(0);
+        let mut current = &mut root_pointer;
         while l1.is_some() || l2.is_some() || carry != 0 {
             let mut v1 = 0;
             let mut v2 = 0;
-            if let Some(mut n1) = l1 {
-                v1 = n1.val;
-                l1 = n1.next.take();
+            if let Some(mut l) = l1 {
+                v1 = l.val;
+                l1 = l.next.take();
             }
-            if let Some(mut n2) = l2 {
-                v2 = n2.val;
-                l2 = n2.next.take();
+            if let Some(mut l) = l2 {
+                v2 = l.val;
+                l2 = l.next.take();
             }
-            let v = (v1 + v2 + carry) % 10;
-            carry = (v1 + v2 + carry) / 10;
-            current.next = Some(Box::new(ListNode::new(v)));
+            let v = v1 + v2 + carry;
+            carry = v / 10;
+            current.next = Some(Box::new(ListNode::new(v % 10)));
             current = current.next.as_mut().unwrap();
         }
 

src/problem/p0003_longest_substring_without_repeating_characters.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::{cmp, collections::HashMap};
 
 /// [3] Longest Substring Without Repeating Characters
 ///
@@ -41,20 +41,16 @@ impl Solution {
             return s.len() as i32;
         }
 
-        let mut map = HashMap::new();
         let mut ret = 0;
         let mut pre = 0;
-        for (i, c) in s.bytes().enumerate() {
-            match map.entry(c) {
-                std::collections::hash_map::Entry::Occupied(o) => {
-                    if o.get() >= &pre {
-                        pre = o.get() + 1;
-                    }
-                }
-                std::collections::hash_map::Entry::Vacant(_) => {}
+        let mut dic = HashMap::new();
+        for (i, b) in s.bytes().enumerate() {
+            if !dic.contains_key(&b) || dic[&b] < pre {
+                ret = cmp::max(ret, i - pre + 1);
+            } else {
+                pre = dic[&b] + 1;
             }
-            ret = ret.max(i - pre + 1);
-            map.insert(c, i);
+            dic.insert(b, i);
         }
 
         ret as i32

src/problem/p0005_longest_palindromic_substring.rs

@@ -31,29 +31,33 @@ impl Solution {
             return s;
         }
 
-        let s = s.as_bytes();
-        let mut ret: &[u8] = &[];
-        for i in 0..s.len() - 1 {
-            let s1 = Solution::pali(s, i as i32, i);
-            let s2 = Solution::pali(s, i as i32, i + 1);
-            if s1.len() > ret.len() {
+        let bb = s.as_bytes();
+        let mut ret: &[_] = &[];
+        for i in 0..bb.len() - 1 {
+            let s1 = Solution::is_pali(bb, i as i32, i);
+            let s2 = Solution::is_pali(bb, i as i32, i + 1);
+            if ret.len() < s1.len() {
                 ret = s1;
             }
-            if s2.len() > ret.len() {
+            if ret.len() < s2.len() {
                 ret = s2;
             }
         }
 
         String::from_utf8_lossy(ret).to_string()
     }
 
-    fn pali(s: &[u8], mut l: i32, mut r: usize) -> &[u8] {
-        while l >= 0 && r < s.len() && s[l as usize] == s[r] {
-            l -= 1;
-            r += 1;
+    fn is_pali(bb: &[u8], mut i: i32, mut j: usize) -> &[u8] {
+        while i >= 0 && j < bb.len() {
+            if bb[i as usize] != bb[j] {
+                break;
+            }
+
+            i -= 1;
+            j += 1;
         }
 
-        &s[(l + 1) as usize..r]
+        &bb[(i + 1) as usize..j]
     }
 }