solve aylei#19 aylei#20

Author: aylei

src/lib.rs

@@ -16,3 +16,5 @@ mod n0015_3sum;
 mod n0016_3sum_closest;
 mod n0017_letter_combinations_of_a_phone_number;
 mod n0018_4sum;
+mod n0019_remove_nth_node_from_end_of_list;
+mod n0020_valid_parentheses;

src/n0019_remove_nth_node_from_end_of_list.rs

@@ -0,0 +1,97 @@
+
+/**
+ * [19] Remove Nth Node From End of List
+ *
+ * Given a linked list, remove the n-th node from the end of list and return its head.
+ * 
+ * Example:
+ * 
+ * 
+ * Given linked list: 1->2->3->4->5, and n = 2.
+ * 
+ * After removing the second node from the end, the linked list becomes 1->2->3->5.
+ * 
+ * 
+ * Note:
+ * 
+ * Given n will always be valid.
+ * 
+ * Follow up:
+ * 
+ * Could you do this in one pass?
+ * 
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+// Definition for singly-linked list.
+ #[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
+     }
+   }
+ }
+
+// one pass (two pointer runner pattern) cannot make borrow checker happy
+// but two pass don't takes longer time
+impl Solution {
+    pub fn remove_nth_from_end(head: Option<Box<ListNode>>, n: i32) -> Option<Box<ListNode>> {
+        let mut dummy_head = Some(Box::new(ListNode {
+            val: 0, next: head,
+        }));
+        let mut len = 0;
+        {
+            let mut p = dummy_head.as_ref();
+            while p.unwrap().next.is_some() {
+                len += 1;
+                p = p.unwrap().next.as_ref();
+            }
+        }
+        let idx = len - n;
+        {
+            let mut p = dummy_head.as_mut();
+            for _ in 0..(idx) {
+                p = p.unwrap().next.as_mut();
+            }
+            let next = p.as_mut().unwrap().next.as_mut().unwrap().next.take();
+            p.as_mut().unwrap().next = next;
+        }
+        dummy_head.unwrap().next
+    }
+}
+
+// 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
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_19() {
+        assert_eq!(Solution::remove_nth_from_end(to_list(vec![1,2,3,4,5]), 2),
+                   to_list(vec![1,2,3,5]));
+        assert_eq!(Solution::remove_nth_from_end(to_list(vec![1]), 1),
+                   None);
+    }
+}

src/n0020_valid_parentheses.rs

@@ -0,0 +1,91 @@
+/**
+ * [20] Valid Parentheses
+ *
+ * Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.
+ * 
+ * An input string is valid if:
+ * 
+ * <ol>
+ * 	Open brackets must be closed by the same type of brackets.
+ * 	Open brackets must be closed in the correct order.
+ * </ol>
+ * 
+ * Note that an empty string is also considered valid.
+ * 
+ * Example 1:
+ * 
+ * 
+ * Input: "()"
+ * Output: true
+ * 
+ * 
+ * Example 2:
+ * 
+ * 
+ * Input: "()[]{}"
+ * Output: true
+ * 
+ * 
+ * Example 3:
+ * 
+ * 
+ * Input: "(]"
+ * Output: false
+ * 
+ * 
+ * Example 4:
+ * 
+ * 
+ * Input: "([)]"
+ * Output: false
+ * 
+ * 
+ * Example 5:
+ * 
+ * 
+ * Input: "{[]}"
+ * Output: true
+ * 
+ * 
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn is_valid(s: String) -> bool {
+        let mut stack: Vec<char> = Vec::new();
+        for ch in s.chars().into_iter() {
+            match stack.last() {
+                None => {},
+                Some(&last) => {
+                    if Solution::pair(last, ch) {
+                        stack.pop();
+                        continue
+                    }
+                },
+            }
+            stack.push(ch);
+        }
+        stack.is_empty()
+    }
+
+    #[inline(always)]
+    fn pair(open: char, close: char) -> bool {
+        (open == '{' && close == '}') ||
+            (open == '(' && close == ')') ||
+            (open == '[' && close == ']')
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_20() {
+        assert_eq!(Solution::is_valid("()[]{}".to_string()), true);
+    }
+}