update leetcode

leetcode_rs/problems/p118/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "p118"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

leetcode_rs/problems/p118/src/main.rs

@@ -0,0 +1,27 @@
+fn generate(num_rows: i32) -> Vec<Vec<i32>> {
+    let mut rows: Vec<Vec<i32>> = Vec::new();
+    let num_rows = num_rows as usize;
+    for i in 0..num_rows {
+        let mut row: Vec<i32> = Vec::new();
+        row.push(1);
+
+        if i > 1 {
+            for j in 1..i {
+                let k = rows[i - 1][j - 1] + rows[i - 1][j];
+                row.push(k);
+            }
+        }
+
+        if i != 0 {
+            row.push(1);
+        }
+
+        rows.push(row);
+    }
+
+    rows
+}
+
+fn main() {
+    dbg!(generate(5));
+}

leetcode_rs/problems/p125/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "p125"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

leetcode_rs/problems/p125/src/main.rs

@@ -0,0 +1,18 @@
+fn is_palindrome(s: String) -> bool {
+    if s.is_empty() {
+        return true;
+    }
+    let s: String = s
+        .chars()
+        .filter(|c| c.is_alphabetic() || c.is_ascii_digit())
+        .map(|c| c.to_ascii_lowercase())
+        .collect();
+
+    let rev_s: String = s.chars().rev().collect();
+    s == rev_s
+}
+
+fn main() {
+    dbg!(is_palindrome("A man, a plan, a canal: Panama".to_string()));
+    dbg!(is_palindrome("0P".to_string()));
+}

leetcode_rs/problems/p136/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "p136"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

leetcode_rs/problems/p136/src/main.rs

@@ -0,0 +1,11 @@
+fn single_number(nums: Vec<i32>) -> i32 {
+    let mut buffer = 0;
+    for num in nums {
+        buffer ^= num;
+    }
+    buffer
+}
+
+fn main() {
+    dbg!(single_number([2, 2, 1].to_vec()));
+}

leetcode_rs/problems/p17/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "p17"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

leetcode_rs/problems/p17/src/main.rs

@@ -0,0 +1,45 @@
+fn letter_combinations(digits: String) -> Vec<String> {
+    if digits.is_empty() {
+        return vec![];
+    }
+    let alpha_set: Vec<Vec<char>> = vec![
+        vec![],                   // 0
+        vec![],                   // 1
+        vec!['a', 'b', 'c'],      // 2
+        vec!['d', 'e', 'f'],      // 3
+        vec!['g', 'h', 'i'],      // 4
+        vec!['j', 'k', 'l'],      // 5
+        vec!['m', 'n', 'o'],      // 6
+        vec!['p', 'q', 'r', 's'], // 7
+        vec!['t', 'u', 'v'],      // 8
+        vec!['w', 'x', 'y', 'z'], // 9
+    ];
+
+    let mut candidate_alpha = Vec::new();
+    for digit in digits.chars() {
+        let digit = digit.to_digit(10).unwrap() as usize;
+        candidate_alpha.push(alpha_set[digit].clone());
+    }
+
+    let total_len: usize = candidate_alpha.iter().map(|x| x.len()).product();
+    let mut result: Vec<String> = vec![String::new(); total_len];
+
+    for (idx, combination) in result.iter_mut().enumerate() {
+        let mut temp_idx = idx;
+        for chars in candidate_alpha.iter().rev() {
+            let char_idx = temp_idx % chars.len();
+            combination.push(chars[char_idx]);
+            temp_idx /= chars.len();
+        }
+        combination
+            .chars()
+            .rev()
+            .collect::<String>()
+            .clone_into(combination);
+    }
+
+    result
+}
+fn main() {
+    dbg!(letter_combinations("234".to_string()));
+}

leetcode_rs/problems/p190/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "p190"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

leetcode_rs/problems/p190/src/main.rs

@@ -0,0 +1,6 @@
+fn reverse_bits(n: i32) -> i32 {
+    n.reverse_bits()
+}
+fn main() {
+    assert_eq!(reverse_bits(43261596), 964176192)
+}

leetcode_rs/problems/p191/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "p191"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

leetcode_rs/problems/p191/src/main.rs

@@ -0,0 +1,7 @@
+fn hamming_weight(n: i32) -> i32 {
+    n.count_ones() as i32
+}
+
+fn main() {
+    assert_eq!(hamming_weight(11), 3);
+}

leetcode_rs/problems/p2/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "p2"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

leetcode_rs/problems/p2/src/main.rs

@@ -0,0 +1,101 @@
+// Definition for singly-linked list.
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct ListNode {
+    pub val: i32,
+    pub next: Option<Box<ListNode>>,
+}
+
+impl ListNode {
+    #[inline]
+    fn new(val: i32) -> Self {
+        ListNode { next: None, val }
+    }
+}
+
+fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+    let mut dummy_head = Box::new(ListNode::new(0));
+    let mut current = &mut dummy_head;
+    let mut p1 = l1.as_ref();
+    let mut p2 = l2.as_ref();
+    let mut carry = 0;
+
+    while p1.is_some() || p2.is_some() || carry != 0 {
+        let val1 = p1.map_or(0, |node| node.val);
+        let val2 = p2.map_or(0, |node| node.val);
+        let sum = val1 + val2 + carry;
+
+        carry = sum / 10;
+        current.next = Some(Box::new(ListNode::new(sum % 10)));
+        current = current.next.as_mut().unwrap();
+
+        p1 = p1.and_then(|node| node.next.as_ref());
+        p2 = p2.and_then(|node| node.next.as_ref());
+    }
+
+    dummy_head.next
+}
+
+fn main() {
+    // 测试用例 1: 342 + 465 = 807
+    let l1 = Some(Box::new(ListNode {
+        val: 2,
+        next: Some(Box::new(ListNode {
+            val: 4,
+            next: Some(Box::new(ListNode { val: 3, next: None })),
+        })),
+    }));
+    let l2 = Some(Box::new(ListNode {
+        val: 5,
+        next: Some(Box::new(ListNode {
+            val: 6,
+            next: Some(Box::new(ListNode { val: 4, next: None })),
+        })),
+    }));
+    let result = add_two_numbers(l1, l2);
+    println!("Test 1: {:?}", result); // 期望: [7, 0, 8]
+
+    // 测试用例 2: 0 + 0 = 0
+    let l1 = Some(Box::new(ListNode::new(0)));
+    let l2 = Some(Box::new(ListNode::new(0)));
+    let result = add_two_numbers(l1, l2);
+    println!("Test 2: {:?}", result); // 期望: [0]
+
+    // 测试用例 3: 99 + 9 = 108 (有进位)
+    let l1 = Some(Box::new(ListNode {
+        val: 9,
+        next: Some(Box::new(ListNode { val: 9, next: None })),
+    }));
+    let l2 = Some(Box::new(ListNode::new(9)));
+    let result = add_two_numbers(l1, l2);
+    println!("Test 3: {:?}", result); // 期望: [8, 0, 1]
+
+    // 测试用例 4: 999 + 1 = 1000 (多位进位)
+    let l1 = Some(Box::new(ListNode {
+        val: 9,
+        next: Some(Box::new(ListNode {
+            val: 9,
+            next: Some(Box::new(ListNode { val: 9, next: None })),
+        })),
+    }));
+    let l2 = Some(Box::new(ListNode::new(1)));
+    let result = add_two_numbers(l1, l2);
+    println!("Test 4: {:?}", result); // 期望: [0, 0, 0, 1]
+
+    // 测试用例 5: 长度不同的链表 12 + 9999 = 10011
+    let l1 = Some(Box::new(ListNode {
+        val: 2,
+        next: Some(Box::new(ListNode { val: 1, next: None })),
+    }));
+    let l2 = Some(Box::new(ListNode {
+        val: 9,
+        next: Some(Box::new(ListNode {
+            val: 9,
+            next: Some(Box::new(ListNode {
+                val: 9,
+                next: Some(Box::new(ListNode { val: 9, next: None })),
+            })),
+        })),
+    }));
+    let result = add_two_numbers(l1, l2);
+    println!("Test 5: {:?}", result); // 期望: [1, 1, 0, 0, 1]
+}

leetcode_rs/problems/p283/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "p283"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

leetcode_rs/problems/p283/src/main.rs

@@ -0,0 +1,12 @@
+fn move_zeroes(nums: &mut Vec<i32>) {
+    let non_zero: Vec<i32> = nums.iter().filter(|&x| *x != 0).cloned().collect();
+    let zero_count = nums.len() - non_zero.len();
+    *nums = non_zero;
+    nums.extend(vec![0; zero_count]);
+}
+
+fn main() {
+    let mut result = vec![0, 1, 0, 3, 12];
+    move_zeroes(&mut result);
+    assert_eq!(result, [1, 3, 12, 0, 0].to_vec());
+}

leetcode_rs/problems/p50/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "p50"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

leetcode_rs/problems/p50/src/main.rs

@@ -0,0 +1,7 @@
+fn my_pow(x: f64, n: i32) -> f64 {
+    x.powi(n)
+}
+
+fn main() {
+    assert_eq!(my_pow(2.0, 10), 1024.0)
+}