number 2: add_two_numbers

Author: aylei

Cargo.toml

@@ -2,5 +2,5 @@
 name = "leetcode-rust"
 version = "0.1.0"
 authors = ["alei <rayingecho@gmail.com>"]
-edition = "2019"
+edition = "2018"
 

README.md

@@ -10,4 +10,4 @@ Run `cargo test test_{id}` to test the solution for problem #id.
 
 Working in progress, solutions list:
 
-* [1 - two sum](./src/two_sum_1.rs)
+* [1 - two sum](src/n1_two_sum.rs)

src/main.rs

@@ -1,5 +1,6 @@
 // make cargo happy
-pub mod two_sum_1;
+pub mod n1_two_sum;
+pub mod n2_add_two_numbers;
 
 fn main() {
 }

src/two_sum_1.rs renamed to src/n1_two_sum.rs

@@ -21,6 +21,8 @@
 
 pub struct Solution {}
 
+// submission codes start here
+
 use std::collections::HashMap;
 impl Solution {
     pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
@@ -35,6 +37,8 @@ impl Solution {
     }
 }
 
+// submission codes end
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/n2_add_two_numbers.rs

@@ -0,0 +1,110 @@
+/*
+ * [2] Add Two Numbers
+ *
+ * https://leetcode.com/problems/add-two-numbers/description/
+ *
+ * algorithms
+ * Medium (30.03%)
+ * Total Accepted:    705.4K
+ * Total Submissions: 2.3M
+ * Testcase Example:  '[2,4,3]\n[5,6,4]'
+ *
+ * You are given two non-empty linked lists representing two non-negative
+ * integers. The digits are stored in reverse order and each of their nodes
+ * contain a single digit. Add the two numbers and return it as a linked list.
+ * 
+ * You may assume the two numbers do not contain any leading zero, except the
+ * number 0 itself.
+ * 
+ * Example:
+ * 
+ * 
+ * Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
+ * Output: 7 -> 0 -> 8
+ * Explanation: 342 + 465 = 807.
+ *
+ */
+
+#[derive(PartialEq, Eq, Debug)]
+pub struct ListNode {
+    pub val: i32,
+    pub next: Option<Box<ListNode>>
+}
+
+impl ListNode {
+    #[inline]
+    fn new(val: i32) -> Self {
+        ListNode {
+            next: None,
+            val
+        }
+    }
+}
+
+// helper function for test
+pub fn to_list(vec: Vec<i32>) -> Option<Box<ListNode>> {
+    let mut current = None;
+    for &v in vec.iter().rev() {
+        let mut node = ListNode::new(v);
+        node.next = current;
+        current = Some(Box::new(node));
+    }
+    current
+}
+
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        let (mut l1, mut l2) = (l1, l2);
+        let mut curr = None;
+        let (mut l1_end, mut l2_end, mut overflow) = (false, false, false);
+        loop {
+            let lhs = match l1 {
+                Some(node) => { l1 = node.next; node.val },
+                None => { l1_end = true; 0 },
+            };
+            let rhs = match l2 {
+                Some(node) => { l2 = node.next; node.val },
+                None => { l2_end = true; 0 }
+            };
+            // if l1, l2 end and there is not overflow from previous operation, return the result
+            if l1_end && l2_end && !overflow {
+                break Solution::reverse(curr);
+            }
+            let sum = lhs + rhs + if overflow { 1 } else { 0 };
+            let sum = if sum >= 10 { overflow = true; sum - 10 } else { overflow = false; sum };
+            let mut node =  ListNode::new(sum);
+            node.next = curr;
+            curr = Some(Box::new(node));
+        }
+    }
+
+    fn reverse(l: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        let mut prev = None;
+        let mut current = l;
+        while let Some(mut current_node_inner) = current {
+            let next = current_node_inner.next;
+            current_node_inner.next = prev;
+            prev = Some(current_node_inner);
+            current = next;
+        }
+        prev
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_2() {
+        assert_eq!(Solution::add_two_numbers(to_list(vec![2, 4, 3]), to_list(vec![5, 6, 4])), to_list(vec![7, 0, 8]));
+
+        assert_eq!(Solution::add_two_numbers(to_list(vec![9, 9, 9, 9]), to_list(vec![9, 9, 9, 9, 9, 9])), to_list(vec![8, 9, 9, 9, 0, 0, 1]));
+    }
+}