add initial data

0005-longest-palindromic-substring/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "leetcode"
+version = "0.1.0"

0005-longest-palindromic-substring/Cargo.toml

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

0005-longest-palindromic-substring/src/main.rs

@@ -0,0 +1,64 @@
+fn main() {
+    println!("Hello, world!");
+}
+
+pub fn longest_palindrome(s: String) -> String {
+    let mut best = Vec::with_capacity(s.len());
+
+    let bytes = s.as_bytes();
+
+    for center in 0..bytes.len() {
+        for (mut left_idx, mut right_idx) in [(center, center), (center, center + 1)] {
+            expand(bytes, &mut left_idx, &mut right_idx);
+
+            if right_idx - left_idx > best.len() {
+                best = bytes[left_idx..right_idx].into();
+            }
+        }
+    }
+    String::from_utf8(best).unwrap()
+}
+
+fn expand(bytes: &[u8], left_idx: &mut usize, right_idx: &mut usize) {
+    loop {
+        if bytes.get(*right_idx).is_none_or(|&r| bytes[*left_idx] != r) {
+            *left_idx += 1;
+            return;
+        }
+        match left_idx.checked_sub(1) {
+            Some(new_left) => *left_idx = new_left,
+            None => {
+                *right_idx += 1;
+                return;
+            }
+        }
+        *right_idx += 1;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::longest_palindrome;
+
+    #[test]
+    fn test_1() {
+        assert!(
+            ["aba".to_string(), "bab".to_string()]
+                .contains(&longest_palindrome("babad".to_string()))
+        );
+    }
+    #[test]
+    fn test_2() {
+        assert_eq!(longest_palindrome("cbbd".to_string()), "bb".to_string());
+    }
+
+    #[test]
+    fn test_3() {
+        assert_eq!(longest_palindrome("whdqcudjpisufnrtsyupwtnnbsvfptrcgvobbjglmpynebblpigaflpbezjvjgbmofejyjssdhbgghgrhzuplbeptpaecfdanhlylgusptlgobkqnulxvnwuzwauewcplnvcwowmbxxnhsdmgxtvbfgnuqdpxennqglgmspbagvmjcmzmbsuacxlqfxjggrwsnbblnnwisvmpwwhomyjylbtedzrptejjsaiqzprnadkjxeqfdpkddmbzokkegtypxaafodjdwirynzurzkjzrkufsokhcdkajwmqvhcbzcnysrbsfxhfvtodqabvbuosxtonbpmgoemcgkudandrioncjigbyizekiakmrfjvezuzddjxqyevyenuebfwugqelxwpirsoyixowcmtgosuggrkdciehktojageynqkazsqxraimeopcsjxcdtzhlbvtlvzytgblwkmbfwmggrkpioeofkrmfdgfwknrbaimhefpzckrzwdvddhdqujffwvtvfyjlimkljrsnnhudyejcrtrwvtsbkxaplchgbikscfcbhovlepdojmqybzhbiionyjxqsmquehkhzdiawfxunguhqhkxqdiiwsbuhosebxrpcstpklukjcsnnzpbylzaoyrmyjatuovmaqiwfdfwyhugbeehdzeozdrvcvghekusiahfxhlzclhbegdnvkzeoafodnqbtanfwixjzirnoaiqamjgkcapeopbzbgtxsjhqurbpbuduqjziznblrhxbydxsmtjdfeepntijqpkuwmqezkhnkwbvwgnkxmkyhlbfuwaslmjzlhocsgtoujabbexvxweigplmlewumcone".to_string()), "wfdfw".to_string());
+    }
+
+    #[test]
+    fn test_4() {
+        assert_eq!(longest_palindrome("a".to_string()), "a".to_string());
+    }
+}

0006-zigzag-conversion/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "leetcode"
+version = "0.1.0"

0006-zigzag-conversion/Cargo.toml

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

0006-zigzag-conversion/src/main.rs

@@ -0,0 +1,53 @@
+fn main() {
+    println!("Hello, world!");
+}
+
+pub fn convert(s: String, num_rows: i32) -> String {
+    let bytes = s.as_bytes();
+    let mut result = vec![vec![]; num_rows as usize];
+
+    for (idx, byte) in bytes.iter().enumerate() {
+        let row = if num_rows == 1 {
+            0
+        } else {
+            let cycle_pos = idx % (2 * (num_rows - 1)) as usize;
+            if cycle_pos < num_rows as usize - 1 {
+                cycle_pos
+            } else {
+                2 * (num_rows as usize - 1) - cycle_pos
+            }
+        };
+
+        result[row].push(*byte);
+    }
+
+    result.into_iter().flatten().map(|b| b as char).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::convert;
+
+    #[test]
+    fn test_1() {
+        assert_eq!(
+            convert("PAYPALISHIRING".to_string(), 3),
+            "PAHNAPLSIIGYIR".to_string()
+        );
+    }
+    #[test]
+    fn test_2() {
+        assert_eq!(
+            convert("PAYPALISHIRING".to_string(), 4),
+            "PINALSIGYAHRPI".to_string()
+        );
+    }
+    #[test]
+    fn test_3() {
+        assert_eq!(convert("A".to_string(), 1), "A".to_string());
+    }
+    #[test]
+    fn test_4() {
+        assert_eq!(convert("AB".to_string(), 1), "AB".to_string());
+    }
+}

0007-reverse-integer/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "leetcode"
+version = "0.1.0"

0007-reverse-integer/Cargo.toml

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

0007-reverse-integer/src/main.rs

@@ -0,0 +1,43 @@
+fn main() {
+    println!("Hello, world!");
+}
+
+fn try_reverse(x: i32) -> Option<i32> {
+    let mut i = x;
+    let mut result: i32 = 0;
+
+    while i != 0 {
+        let digit = i % 10;
+        result = result.checked_mul(10)?.checked_add(digit)?;
+
+        i /= 10;
+    }
+
+    Some(result)
+}
+
+pub fn reverse(x: i32) -> i32 {
+    try_reverse(x).unwrap_or(0)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::reverse;
+
+    #[test]
+    fn test_1() {
+        assert_eq!(reverse(123), 321);
+    }
+    #[test]
+    fn test_2() {
+        assert_eq!(reverse(-123), -321);
+    }
+    #[test]
+    fn test_3() {
+        assert_eq!(reverse(120), 21);
+    }
+    #[test]
+    fn test_4() {
+        assert_eq!(reverse(1534236469), 0);
+    }
+}

0008-string-to-integer-atoi/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "leetcode"
+version = "0.1.0"

0008-string-to-integer-atoi/Cargo.toml

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

0008-string-to-integer-atoi/src/main.rs

@@ -0,0 +1,94 @@
+fn main() {
+    println!("Hello, world!");
+}
+pub fn my_atoi(s: String) -> i32 {
+    let mut chars = s.trim().chars().peekable();
+
+    let is_negative = match chars.peek() {
+        Some(&'+') => {
+            chars.next();
+            false
+        }
+        Some(&'-') => {
+            chars.next();
+            true
+        }
+        _ => false,
+    };
+
+    let mut accum: i64 = 0;
+    for c in chars {
+        let Some(digit) = c.to_digit(10) else {
+            break;
+        };
+        accum = accum * 10 - digit as i64;
+        accum = accum.max(i32::MIN as i64);
+    }
+
+    if is_negative {
+        accum as i32
+    } else {
+        (-accum).min(i32::MAX as i64) as i32
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::my_atoi;
+
+    #[test]
+    fn test_1() {
+        assert_eq!(my_atoi("42".to_string()), 42);
+    }
+
+    #[test]
+    fn test_2() {
+        assert_eq!(my_atoi("  -042".to_string()), -42);
+    }
+
+    #[test]
+    fn test_3() {
+        assert_eq!(my_atoi("1337c0d3".to_string()), 1337);
+    }
+
+    #[test]
+    fn test_4() {
+        assert_eq!(my_atoi("0-1".to_string()), 0);
+    }
+
+    #[test]
+    fn test_5() {
+        assert_eq!(my_atoi("words and 987".to_string()), 0);
+    }
+
+    #[test]
+    fn test_6() {
+        assert_eq!(my_atoi((i32::MAX as i64 + 1).to_string()), i32::MAX);
+    }
+
+    #[test]
+    fn test_7() {
+        assert_eq!(my_atoi((i32::MAX).to_string()), i32::MAX);
+    }
+
+    #[test]
+    fn test_8() {
+        assert_eq!(my_atoi("9223372036854775808".to_string()), i32::MAX);
+    }
+
+    #[test]
+    fn test_9() {
+        assert_eq!(
+            my_atoi("1234567890123456789012345678901234567890".to_string()),
+            i32::MAX
+        );
+    }
+
+    #[test]
+    fn test_10() {
+        assert_eq!(
+            my_atoi("10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000522545459".to_string()),
+            i32::MAX
+        );
+    }
+}

0011-container-with-most-water/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "leetcode"
+version = "0.1.0"

0011-container-with-most-water/Cargo.toml

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

0011-container-with-most-water/src/main.rs

@@ -0,0 +1,37 @@
+fn main() {
+    println!("Hello, world!");
+}
+
+pub fn max_area(height: Vec<i32>) -> i32 {
+    let mut best = 0;
+
+    let mut left = 0;
+    let mut right = height.len() - 1;
+
+    while left != right {
+        let area = height[left].min(height[right]) * (right - left) as i32;
+        best = best.max(area);
+        if height[left] < height[right] {
+            left += 1;
+        } else {
+            right -= 1;
+        }
+    }
+
+    best
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::max_area;
+
+    #[test]
+    fn test_1() {
+        assert_eq!(max_area(vec![1, 8, 6, 2, 5, 4, 8, 3, 7]), 49);
+    }
+
+    #[test]
+    fn test_2() {
+        assert_eq!(max_area(vec![1, 1]), 1);
+    }
+}

0012-integer-to-roman/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "leetcode"
+version = "0.1.0"

0012-integer-to-roman/Cargo.toml

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

0012-integer-to-roman/src/main.rs

@@ -0,0 +1,54 @@
+static ROMAN_VALUES: [(i32, &str); 13] = [
+    (1000, "M"),
+    (900, "CM"),
+    (500, "D"),
+    (400, "CD"),
+    (100, "C"),
+    (90, "XC"),
+    (50, "L"),
+    (40, "XL"),
+    (10, "X"),
+    (9, "IX"),
+    (5, "V"),
+    (4, "IV"),
+    (1, "I"),
+];
+
+pub fn int_to_roman(num: i32) -> String {
+    let mut num = num;
+
+    let mut buf = String::new();
+
+    for (subtrahend, letters) in ROMAN_VALUES {
+        while let Some(n) = num.checked_sub(subtrahend)
+            && n >= 0
+        {
+            num = n;
+            buf.push_str(letters);
+        }
+    }
+
+    buf
+}
+
+fn main() {}
+
+#[cfg(test)]
+mod tests {
+    use crate::int_to_roman;
+
+    #[test]
+    fn test_1() {
+        assert_eq!(int_to_roman(3749), "MMMDCCXLIX");
+    }
+
+    #[test]
+    fn test_2() {
+        assert_eq!(int_to_roman(58), "LVIII");
+    }
+
+    #[test]
+    fn test_3() {
+        assert_eq!(int_to_roman(1994), "MCMXCIV");
+    }
+}

0013-roman-to-integer/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "leetcode"
+version = "0.1.0"

0013-roman-to-integer/Cargo.toml

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

0013-roman-to-integer/src/main.rs

@@ -0,0 +1,59 @@
+static ROMAN_VALUES: [(i32, &str); 13] = [
+    (1, "I"),
+    (4, "IV"),
+    (5, "V"),
+    (9, "IX"),
+    (10, "X"),
+    (40, "XL"),
+    (50, "L"),
+    (90, "XC"),
+    (100, "C"),
+    (400, "CD"),
+    (500, "D"),
+    (900, "CM"),
+    (1000, "M"),
+];
+
+pub fn roman_to_int(s: String) -> i32 {
+    let mut s = s;
+
+    let mut result = 0;
+
+    for (num, letters) in ROMAN_VALUES {
+        loop {
+            let left = s.len().saturating_sub(letters.len());
+            let part = &s[left..];
+
+            if part == letters {
+                result += num;
+                s.truncate(left);
+            } else {
+                break;
+            }
+        }
+    }
+
+    result
+}
+
+fn main() {}
+
+#[cfg(test)]
+mod tests {
+    use crate::roman_to_int;
+
+    #[test]
+    fn test_1() {
+        assert_eq!(roman_to_int("MMMDCCXLIX".to_string()), 3749);
+    }
+
+    #[test]
+    fn test_2() {
+        assert_eq!(roman_to_int("LVIII".to_string()), 58);
+    }
+
+    #[test]
+    fn test_3() {
+        assert_eq!(roman_to_int("MCMXCIV".to_string()), 1994);
+    }
+}

0015-3sum/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "leetcode"
+version = "0.1.0"

0015-3sum/Cargo.toml

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

0015-3sum/src/main.rs

@@ -0,0 +1,88 @@
+fn main() {
+    println!("Hello, world!");
+}
+
+pub fn three_sum(nums: Vec<i32>) -> Vec<Vec<i32>> {
+    let mut result = vec![];
+
+    if nums.len() < 3 {
+        return result;
+    }
+
+    let mut nums: Vec<_> = nums;
+    nums.sort_unstable();
+
+    for idx in 0..nums.len() - 1 {
+        let first = nums[idx];
+
+        if first > 0 {
+            // no more negative numbers left, so we are done
+            break;
+        }
+
+        if idx > 0 && first == nums[idx - 1] {
+            // we already scanned for this number
+            continue;
+        }
+        let mut left = idx + 1;
+        let mut right = nums.len() - 1;
+
+        while left < right {
+            let sum = first + nums[left] + nums[right];
+            if sum == 0 {
+                let entry = vec![first, nums[left], nums[right]];
+                result.push(entry);
+
+                // skip identical numbers that would lead to the same combinations
+                while nums[left + 1] == nums[left] && left < nums.len() - 2 {
+                    left += 1;
+                }
+
+                while nums[right - 1] == nums[right] && right > 1 {
+                    right -= 1;
+                }
+            }
+            if sum <= 0 {
+                left += 1;
+            } else {
+                right -= 1;
+            }
+        }
+    }
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::three_sum;
+
+    #[test]
+    fn test_1() {
+        let sums = three_sum(vec![-1, 0, 1, 2, -1, -4]);
+
+        assert_eq!(sums.len(), 2);
+        assert!(sums.contains(&vec![-1, -1, 2]));
+        assert!(sums.contains(&vec![-1, 0, 1]));
+    }
+
+    #[test]
+    fn test_2() {
+        let sums = three_sum(vec![0, 1, 1]);
+        assert_eq!(sums, Vec::<Vec<i32>>::new());
+    }
+
+    #[test]
+    fn test_3() {
+        let sums = three_sum(vec![0, 0, 0]);
+        assert_eq!(sums, vec![vec![0, 0, 0]]);
+    }
+
+    #[test]
+    fn test_4() {
+        let sums = three_sum(vec![
+            2, -3, 0, -2, -5, -5, -4, 1, 2, -2, 2, 0, 2, -4, 5, 5, -10,
+        ]);
+        assert_eq!(sums.len(), 6);
+    }
+}

0017-letter-combinations-of-a-phone-number/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "leetcode"
+version = "0.1.0"

0017-letter-combinations-of-a-phone-number/Cargo.toml

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

0017-letter-combinations-of-a-phone-number/src/main.rs

@@ -0,0 +1,66 @@
+pub fn letter_combinations(digits: String) -> Vec<String> {
+    let mut current = Vec::new();
+    current.push("".to_string());
+
+    let mut next = Vec::new();
+
+    for digit in digits.chars() {
+        for entry in current.drain(..) {
+            for letter in to_letter(digit) {
+                let mut this_entry = entry.clone();
+                this_entry.push(letter);
+                next.push(this_entry);
+            }
+        }
+        std::mem::swap(&mut current, &mut next);
+        next.clear();
+    }
+
+    current
+}
+
+fn to_letter(digit: char) -> impl Iterator<Item = char> {
+    let letters: &'static [char] = match digit {
+        '2' => &['a', 'b', 'c'],
+        '3' => &['d', 'e', 'f'],
+        '4' => &['g', 'h', 'i'],
+        '5' => &['j', 'k', 'l'],
+        '6' => &['m', 'n', 'o'],
+        '7' => &['p', 'q', 'r', 's'],
+        '8' => &['t', 'u', 'v'],
+        '9' => &['w', 'x', 'y', 'z'],
+        _ => panic!(),
+    };
+    letters.iter().copied()
+}
+
+fn main() {
+    println!("Hello, world!");
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashSet;
+
+    use crate::letter_combinations;
+
+    #[test]
+    fn test_1() {
+        let letters = letter_combinations("23".to_string())
+            .into_iter()
+            .collect::<HashSet<_>>();
+        for example in ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"] {
+            assert!(letters.contains(example));
+        }
+    }
+
+    #[test]
+    fn test_2() {
+        let letters = letter_combinations("2".to_string())
+            .into_iter()
+            .collect::<HashSet<_>>();
+        for example in ["a", "b", "c"] {
+            assert!(letters.contains(example));
+        }
+    }
+}

0019-remove-nth-node-from-end-of-list/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "leetcode"
+version = "0.1.0"

0019-remove-nth-node-from-end-of-list/Cargo.toml

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

0019-remove-nth-node-from-end-of-list/src/main.rs

@@ -0,0 +1,45 @@
+fn main() {
+    println!("Hello, world!");
+}
+
+// created with guidance from claude
+
+pub fn remove_nth_from_end(head: Option<Box<ListNode>>, n: i32) -> Option<Box<ListNode>> {
+    let mut dummy = ListNode::new(0);
+    dummy.next = head;
+
+    let mut current = &dummy.next;
+
+    let mut length = 0;
+
+    while let Some(node) = current {
+        length += 1;
+        current = &node.next;
+    }
+
+    let predecessor = length - n;
+
+    let mut current = &mut dummy.next;
+    for _ in 0..predecessor {
+        current = &mut current.as_mut().unwrap().next;
+    }
+
+    *current = current.take().unwrap().next;
+
+    dummy.next
+}
+
+////////////////////////////////
+
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct ListNode {
+    pub val: i32,
+    pub next: Option<Box<ListNode>>,
+}
+
+impl ListNode {
+    #[inline]
+    pub fn new(val: i32) -> Self {
+        ListNode { next: None, val }
+    }
+}

0020-valid-parentheses/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "leetcode"
+version = "0.1.0"

0020-valid-parentheses/Cargo.toml

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

0020-valid-parentheses/src/main.rs

@@ -0,0 +1,64 @@
+fn main() {
+    println!("Hello, world!");
+}
+
+pub fn is_valid(s: String) -> bool {
+    helper(s).unwrap_or(false)
+}
+
+fn helper(s: String) -> Option<bool> {
+    let mut stack = vec![];
+
+    for c in s.chars() {
+        if ['(', '[', '{'].contains(&c) {
+            stack.push(c);
+        }
+        if [')', ']', '}'].contains(&c) {
+            if matches(c, *stack.last()?) {
+                stack.pop();
+            } else {
+                return Some(false);
+            }
+        }
+    }
+    Some(stack.is_empty())
+}
+
+fn matches(current: char, previous: char) -> bool {
+    match current {
+        ')' => previous == '(',
+        ']' => previous == '[',
+        '}' => previous == '{',
+        _ => unreachable!(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::is_valid;
+
+    #[test]
+    fn test_1() {
+        assert!(is_valid("()".to_string()))
+    }
+
+    #[test]
+    fn test_2() {
+        assert!(is_valid("()[]{}".to_string()))
+    }
+
+    #[test]
+    fn test_3() {
+        assert!(!is_valid("(]".to_string()))
+    }
+
+    #[test]
+    fn test_4() {
+        assert!(is_valid("([])".to_string()))
+    }
+
+    #[test]
+    fn test_5() {
+        assert!(!is_valid("([)]".to_string()))
+    }
+}

add-two-numbers/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "add-two-numbers"
+version = "0.1.0"

add-two-numbers/Cargo.toml

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

add-two-numbers/src/main.rs

@@ -0,0 +1,77 @@
+fn main() {
+    let l1 = to_nodes(942);
+    let l2 = to_nodes(9465);
+    let result = *add_two_numbers(l1, l2).unwrap();
+    dbg!(result);
+}
+
+fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+    let mut l1 = l1;
+    let mut l2 = l2;
+
+    let mut carry = false;
+    let mut head = None;
+    let mut tail = &mut head;
+
+    while l1.is_some() || l2.is_some() || carry {
+        let a = l1.as_ref().map_or(0, |n| n.val);
+        let b = l2.as_ref().map_or(0, |n| n.val);
+
+        let addition = a + b + carry as i32;
+
+        let node = Box::new(ListNode::new(addition % 10));
+        carry = addition >= 10;
+
+        *tail = Some(node);
+        tail = &mut tail.as_mut().unwrap().next;
+
+        l1 = l1.and_then(|n| n.next);
+        l2 = l2.and_then(|n| n.next);
+    }
+
+    head
+}
+
+/////////////////////////////
+
+// 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 to_nodes(number: i32) -> Option<Box<ListNode>> {
+    let digits = number
+        .to_string()
+        .chars()
+        .map(|c| c.to_string().parse().unwrap())
+        .rev()
+        .collect::<Vec<i32>>();
+
+    let mut node = ListNode::new(digits[0]);
+
+    for item in digits.iter().skip(1) {
+        push(&mut node, *item);
+    }
+
+    Some(Box::new(node))
+}
+
+fn push(node: &mut ListNode, digit: i32) {
+    if node.next.is_some() {
+        push(node.next.as_mut().unwrap(), digit);
+    } else {
+        let new = ListNode::new(digit);
+        node.next = Some(Box::new(new));
+    }
+}

find-the-index-of-the-first-occurrence-in-a-string/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "find-the-index-of-the-first-occurrence-in-a-string"
+version = "0.1.0"

find-the-index-of-the-first-occurrence-in-a-string/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "find-the-index-of-the-first-occurrence-in-a-string"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

find-the-index-of-the-first-occurrence-in-a-string/src/main.rs

@@ -0,0 +1,20 @@
+fn main() {
+    println!("{}", str_str("leetcode".to_string(), "leeto".to_string()));
+}
+
+fn str_str(haystack: String, needle: String) -> i32 {
+    if needle.len() > haystack.len() {
+        return -1;
+    }
+
+    let length = needle.len();
+
+    for i in 0..haystack.len() - length + 1 {
+        let substring = &haystack[i..i + length];
+        if substring == needle {
+            return i as _;
+        }
+    }
+
+    -1
+}

length-of-last-word/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "length-of-last-word"
+version = "0.1.0"

length-of-last-word/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "length-of-last-word"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

length-of-last-word/src/main.rs

@@ -0,0 +1,7 @@
+fn main() {
+    dbg!(length_of_last_word("Hello World".to_string()));
+}
+
+fn length_of_last_word(s: String) -> i32 {
+    s.split_whitespace().last().unwrap().len() as _
+}

longest-common-prefix/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "longest-common-prefix"
+version = "0.1.0"

longest-common-prefix/Cargo.toml

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

longest-common-prefix/src/main.rs

@@ -0,0 +1,28 @@
+fn main() {
+    println!("Hello, world!");
+}
+
+fn longest_common_prefix(strs: Vec<String>) -> String {
+    let mut strs = strs;
+
+    strs.sort_by_key(|x| x.len());
+
+    let chars = strs
+        .into_iter()
+        .map(|s| s.chars().collect::<Vec<char>>())
+        .collect::<Vec<_>>();
+
+    let first_word_chars = chars.first().unwrap();
+
+    let mut result = String::new();
+
+    for (i, c) in first_word_chars.iter().enumerate() {
+        if chars.iter().all(|vc| vc[i] == *c) {
+            result.push(*c);
+        } else {
+            return result;
+        }
+    }
+
+    result
+}

longest-substring-without-repeating-characters/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "longest-substring-without-repeating-characters"
+version = "0.1.0"

longest-substring-without-repeating-characters/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "longest-substring-without-repeating-characters"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

longest-substring-without-repeating-characters/src/main.rs

@@ -0,0 +1,58 @@
+fn main() {}
+
+fn length_of_longest_substring(s: String) -> i32 {
+    if s.is_empty() {
+        return 0;
+    }
+
+    let mut char_idx_map = [-1_i64; 128];
+
+    let mut left: usize = 0;
+    let mut right: usize = 1;
+
+    let mut best = 0;
+
+    let bytes = s.as_bytes();
+
+    while right <= s.len() {
+        let last_char = bytes[right - 1];
+
+        let last_seen = char_idx_map[last_char as usize];
+
+        if last_seen >= left as i64 {
+            left = (last_seen + 1) as usize;
+            right = right.max(left + 1);
+        } else {
+            best = best.max(right - left);
+            char_idx_map[last_char as usize] = right as i64 - 1;
+            right += 1;
+        }
+    }
+    best as _
+}
+
+#[cfg(test)]
+mod tests {
+    use super::length_of_longest_substring;
+
+    #[test]
+    fn test1() {
+        assert_eq!(length_of_longest_substring("abcabcbb".to_string()), 3);
+    }
+    #[test]
+    fn test2() {
+        assert_eq!(length_of_longest_substring("bbbbb".to_string()), 1);
+    }
+    #[test]
+    fn test3() {
+        assert_eq!(length_of_longest_substring("pwwkew".to_string()), 3);
+    }
+    #[test]
+    fn test4() {
+        assert_eq!(length_of_longest_substring("".to_string()), 0);
+    }
+    #[test]
+    fn test5() {
+        assert_eq!(length_of_longest_substring("S".to_string()), 1);
+    }
+}

palindrome-number/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "palindrome-number"
+version = "0.1.0"

palindrome-number/Cargo.toml

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

palindrome-number/src/main.rs

@@ -0,0 +1,20 @@
+fn main() {
+    println!("Hello, world!");
+}
+
+fn is_palindrome(x: i32) -> bool {
+    if x < 0 {
+        return false;
+    }
+
+    let mut original = x;
+    let mut reversed = 0;
+
+    while original > 0 {
+        let digit = original % 10;
+        reversed = reversed * 10 + digit;
+        original /= 10;
+    }
+
+    x == reversed
+}

remove-duplicates-from-sorted-array/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "remove-duplicates-from-sorted-array"
+version = "0.1.0"

remove-duplicates-from-sorted-array/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "remove-duplicates-from-sorted-array"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

remove-duplicates-from-sorted-array/src/main.rs

@@ -0,0 +1,32 @@
+fn main() {
+    let mut v = vec![1, 1, 2];
+    dbg!(remove_duplicates(&mut v));
+    dbg!(v);
+
+    let mut v = vec![0, 0, 1, 1, 1, 2, 2, 3, 3, 4];
+    dbg!(remove_duplicates(&mut v));
+    dbg!(v);
+}
+
+fn remove_duplicates(nums: &mut Vec<i32>) -> i32 {
+    let mut result = 1;
+
+    let mut unique_nums = vec![nums.first().cloned().unwrap()];
+    let mut previous = *unique_nums.first().unwrap();
+
+    for item in &mut *nums {
+        if *item != previous {
+            result += 1;
+            unique_nums.push(*item);
+            previous = *item;
+        }
+    }
+
+    // write back
+    nums.clear();
+    for item in unique_nums {
+        nums.push(item);
+    }
+
+    result
+}

remove-element/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "remove-element"
+version = "0.1.0"

remove-element/Cargo.toml

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

remove-element/src/main.rs

@@ -0,0 +1,29 @@
+fn main() {
+    let mut v = vec![3, 2, 2, 3];
+    dbg!(remove_element(&mut v, 3));
+    dbg!(v);
+
+    let mut v = vec![0, 1, 2, 2, 3, 0, 4, 2];
+    dbg!(remove_element(&mut v, 2));
+    dbg!(v);
+}
+
+fn remove_element(nums: &mut Vec<i32>, val: i32) -> i32 {
+    let mut result = 0;
+
+    let mut removed = vec![];
+
+    for item in nums.iter() {
+        if *item != val {
+            removed.push(*item);
+            result += 1;
+        }
+    }
+
+    nums.clear();
+    for item in removed {
+        nums.push(item)
+    }
+
+    result
+}

search-insert-position/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "search-insert-position"
+version = "0.1.0"

search-insert-position/Cargo.toml

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

search-insert-position/src/main.rs

@@ -0,0 +1,19 @@
+fn main() {
+    let vec = vec![1, 3, 5, 6];
+    dbg!(search_insert(vec, 5));
+
+    let vec = vec![1, 3, 5, 6];
+    dbg!(search_insert(vec, 2));
+
+    let vec = vec![1, 3, 5, 6];
+    dbg!(search_insert(vec, 7));
+}
+
+fn search_insert(nums: Vec<i32>, target: i32) -> i32 {
+    for (i, item) in nums.iter().enumerate() {
+        if *item >= target {
+            return i as _;
+        }
+    }
+    nums.len() as _
+}

two-sum/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "two-sum"
+version = "0.1.0"

two-sum/Cargo.toml

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

two-sum/src/main.rs

@@ -0,0 +1,45 @@
+struct Solution;
+
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn two_sum_o_n(nums: Vec<i32>, target: i32) -> Vec<i32> {
+        // value -> idx map
+        let mut map: HashMap<i32, usize> = HashMap::with_capacity(nums.len());
+
+        for (idx, num) in nums.iter().enumerate() {
+            let diff = target - *num;
+            if let Some(idx2) = map.get(&diff) {
+                return vec![idx as _, *idx2 as _];
+            }
+            map.insert(*num, idx);
+        }
+
+        unreachable!("we are guaranteed an answer exists")
+    }
+
+    pub fn two_sum_o_n_log_n(nums: Vec<i32>, target: i32) -> Vec<i32> {
+        let mut indexed_nums: Vec<_> = nums.into_iter().enumerate().collect();
+        indexed_nums.sort_unstable_by_key(|(_, val)| *val);
+
+        let mut left = 0;
+        let mut right = indexed_nums.len() - 1;
+
+        while left < right {
+            let sum = indexed_nums[left].1 + indexed_nums[right].1;
+            if sum == target {
+                return vec![indexed_nums[left].0 as _, indexed_nums[right].0 as _];
+            } else if sum > target {
+                right -= 1;
+            } else {
+                left += 1;
+            }
+        }
+
+        unreachable!("we are guaranteed a solution exists")
+    }
+}
+
+fn main() {
+    println!("Hello, world!");
+}

valid-parentheses/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "valid-parentheses"
+version = "0.1.0"

valid-parentheses/Cargo.toml

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

valid-parentheses/src/main.rs

@@ -0,0 +1,41 @@
+fn main() {
+    dbg!(is_valid("()".to_string()));
+    dbg!(is_valid("()[]{}".to_string()));
+    dbg!(is_valid("(]".to_string()));
+    dbg!(is_valid("([])".to_string()));
+    dbg!(is_valid("([)])".to_string()));
+}
+
+fn is_valid(s: String) -> bool {
+    let mut stack = vec![];
+    for c in s.chars() {
+        if OPEN.contains(&c) {
+            stack.push(c);
+        } else {
+            let last = stack.last();
+            if last.is_none() {
+                return false;
+            }
+            if matches(*last.unwrap(), c) {
+                stack.pop();
+            } else {
+                return false;
+            }
+        }
+    }
+    if !stack.is_empty() {
+        return false;
+    }
+    true
+}
+
+fn matches(c1: char, c2: char) -> bool {
+    (c1 == '(' && c2 == ')')
+        || (c1 == ')' && c2 == '(')
+        || (c1 == '[' && c2 == ']')
+        || (c1 == ']' && c2 == '(')
+        || (c1 == '{' && c2 == '}')
+        || (c1 == '}' && c2 == '{')
+}
+
+const OPEN: [char; 3] = ['(', '[', '{'];