6 files changed, 250 insertions, 0 deletions
diff --git a/works/solutions/.gitignore b/works/solutions/.gitignore
new file mode 100644
index 0000000..6936990
--- /dev/null
+++ b/works/solutions/.gitignore
@@ -0,0 +1,3 @@
+/target
+**/*.rs.bk
+Cargo.lock
diff --git a/works/solutions/Cargo.toml b/works/solutions/Cargo.toml
new file mode 100644
index 0000000..1073387
--- /dev/null
+++ b/works/solutions/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "crupest-leetcode"
+version = "0.1.0"
+authors = ["杨宇千 <crupest@outlook.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/works/solutions/src/add_two_numbers.rs b/works/solutions/src/add_two_numbers.rs
new file mode 100644
index 0000000..3e3122a
--- /dev/null
+++ b/works/solutions/src/add_two_numbers.rs
@@ -0,0 +1,160 @@
+use super::Solution;
+
+/******************** provided code ********************/
+#[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 }
+    }
+}
+
+/******************** my code ********************/
+
+use std::ptr::NonNull;
+
+struct List {
+    head: Option<Box<ListNode>>,
+    tail: NonNull<Option<Box<ListNode>>>,
+}
+
+impl List {
+    fn new() -> List {
+        let mut result = List {
+            head: None,
+            tail: NonNull::dangling(),
+        };
+        result.tail = NonNull::from(&mut result.head);
+        return result;
+    }
+
+    fn append(&mut self, val: i32) {
+        let node = Some(Box::new(ListNode::new(val)));
+        unsafe {
+            match self.tail.as_mut() {
+                None => {
+                    self.head = node;
+                    self.tail = NonNull::from(&mut self.head);
+                }
+                Some(t) => {
+                    t.next = node;
+                    self.tail = NonNull::from(&mut t.next);
+                }
+            }
+        }
+    }
+
+    fn to_result(self) -> Option<Box<ListNode>> {
+        self.head
+    }
+}
+
+impl Solution {
+    pub 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 result = List::new();
+        let mut carry = false;
+
+        loop {
+            match l1 {
+                None => {
+                    while let Some(v) = l2 {
+                        let digit = v.val + if carry { 1 } else { 0 };
+                        carry = digit > 9;
+                        let digit = digit % 10;
+                        result.append(digit);
+                        l2 = v.next;
+                    }
+                    break;
+                }
+                Some(v1) => match l2 {
+                    None => {
+                        let digit = v1.val + if carry { 1 } else { 0 };
+                        carry = digit > 9;
+                        let digit = digit % 10;
+                        result.append(digit);
+                        l1 = v1.next;
+                        while let Some(v) = l1 {
+                            let digit = v.val + if carry { 1 } else { 0 };
+                            carry = digit > 9;
+                            let digit = digit % 10;
+                            result.append(digit);
+                            l1 = v.next;
+                        }
+                        break;
+                    }
+                    Some(v2) => {
+                        let digit = v1.val + v2.val + if carry { 1 } else { 0 };
+                        carry = digit > 9;
+                        let digit = digit % 10;
+                        result.append(digit);
+                        l1 = v1.next;
+                        l2 = v2.next;
+                    }
+                },
+            }
+        }
+
+        if carry {
+            result.append(1);
+        }
+
+        return result.to_result();
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::{List, ListNode, Solution};
+
+    trait IntoList {
+        fn into_list(self) -> Option<Box<ListNode>>;
+    }
+
+    trait IntoVec {
+        fn into_vec(self) -> Vec<i32>;
+    }
+
+    impl IntoList for Vec<i32> {
+        fn into_list(self) -> Option<Box<ListNode>> {
+            let mut list = List::new();
+            for i in self {
+                list.append(i);
+            }
+            list.to_result()
+        }
+    }
+
+    impl IntoVec for Option<Box<ListNode>> {
+        fn into_vec(self) -> Vec<i32> {
+            let mut result = Vec::new();
+            let mut node = self;
+            while let Some(v) = node {
+                result.push(v.val);
+                node = v.next;
+            }
+            result
+        }
+    }
+
+    #[test]
+    fn test() {
+        assert_eq!(
+            Solution::add_two_numbers(vec![2, 4, 3].into_list(), vec![5, 6, 4].into_list()).into_vec(),
+            vec![7, 0, 8]
+        );
+        assert_eq!(
+            Solution::add_two_numbers(vec![9, 9, 9].into_list(), vec![1].into_list()).into_vec(),
+            vec![0, 0, 0, 1]
+        );
+    }
+}
diff --git a/works/solutions/src/length_of_longest_substring.rs b/works/solutions/src/length_of_longest_substring.rs
new file mode 100644
index 0000000..cebcc72
--- /dev/null
+++ b/works/solutions/src/length_of_longest_substring.rs
@@ -0,0 +1,49 @@
+use super::Solution;
+
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn length_of_longest_substring(s: String) -> i32 {
+        let mut map = HashMap::new();
+        let mut last_index = 0;
+        let mut result = 0;
+        let bytes = s.as_bytes();
+        for (i, c) in bytes.iter().enumerate() {
+            match map.get(&c) {
+                Some(vi) if *vi >= last_index => {
+                    last_index = *vi + 1;
+                    map.insert(c, i);
+                }
+                _ => {
+                    map.insert(c, i);
+                    let length = i - last_index + 1;
+                    if length > result {
+                        result = length;
+                    }
+                }
+            }
+        }
+        result as i32
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test() {
+        assert_eq!(
+            Solution::length_of_longest_substring("abcabcbb".to_string()),
+            3
+        );
+        assert_eq!(
+            Solution::length_of_longest_substring("bbbbb".to_string()),
+            1
+        );
+        assert_eq!(
+            Solution::length_of_longest_substring("pwwkew".to_string()),
+            3
+        );
+    }
+}
diff --git a/works/solutions/src/lib.rs b/works/solutions/src/lib.rs
new file mode 100644
index 0000000..2bbe624
--- /dev/null
+++ b/works/solutions/src/lib.rs
@@ -0,0 +1,5 @@
+pub mod two_sum;
+pub mod add_two_numbers;
+pub mod length_of_longest_substring;
+
+pub struct Solution;
diff --git a/works/solutions/src/two_sum.rs b/works/solutions/src/two_sum.rs
new file mode 100644
index 0000000..9f400aa
--- /dev/null
+++ b/works/solutions/src/two_sum.rs
@@ -0,0 +1,24 @@
+use super::Solution;
+
+impl Solution {
+    pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
+        for (i, v1) in nums.iter().enumerate() {
+            for (j, v2) in nums.iter().enumerate().skip(i + 1) {
+                if v1 + v2 == target {
+                    return vec![i as i32, j as i32];
+                }
+            }
+        }
+        panic!();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    pub fn test() {
+        assert_eq!(Solution::two_sum(vec![2, 7, 11, 15], 9), vec![0, 1])
+    }
+}
+\ No newline at end of file