Merge pull request #17 from jtr109/349-intersection-of-two-arrays

349 intersection of two arrays

Author: jtr109

Cargo.lock

@@ -8,4 +8,5 @@ members = [
     "two_sum",
     "implement_queue_using_stacks",
     "merge_sorted_array",
+    "intersection_of_two_arrays",
 ]

Cargo.toml

@@ -14,6 +14,7 @@ Resolving problems of LeetCode in RustLang.
 * [145. Binary Tree Postorder Traversal](./binary_tree_postorder_traversal/src/lib.rs)
 * [215. Kth Largest Element in an Array](./kth_largest/src/lib.rs)
 * [232. Implement Queue using Stacks](./implement_queue_using_stacks/src/lib.rs)
+* [349. Intersection of Two Arrays](./intersection_of_two_arrays/src/lib.rs)
 
 ## Document
 

README.md

@@ -0,0 +1,9 @@
+[package]
+name = "intersection_of_two_arrays"
+version = "0.1.0"
+authors = ["Ryan Li <conbas2019@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

intersection_of_two_arrays/Cargo.toml

@@ -0,0 +1,70 @@
+/*!
+ * # 349. Intersection of Two Arrays
+ *
+ * * [Problem link](https://leetcode.com/problems/intersection-of-two-arrays/)
+ */
+
+#![allow(dead_code)]
+
+struct Solution {}
+
+// ----------------------------------------------------------------------------
+
+impl Solution {
+    pub fn intersection(nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
+        let mut sorted1 = nums1;
+        let mut sorted2 = nums2;
+        sorted1.sort();
+        sorted2.sort();
+        let (mut i, mut j) = (0, 0);
+        let mut inter = vec![];
+        while i < sorted1.len() && j < sorted2.len() {
+            let n1 = sorted1[i];
+            let n2 = sorted2[j];
+            if n1 < n2 {
+                i += 1;
+            } else if n1 > n2 {
+                j += 1;
+            } else {
+                inter.push(n1);
+                i += 1;
+                j += 1;
+                while i < sorted1.len() && sorted1[i] == n1 {
+                    i += 1;
+                }
+                while j < sorted2.len() && sorted2[j] == n1 {
+                    j += 1;
+                }
+            }
+        }
+        inter
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashSet;
+
+    fn assert_equal(left: Vec<i32>, right: Vec<i32>) {
+        let l = left.iter().cloned().collect::<HashSet<i32>>();
+        let r = right.iter().cloned().collect::<HashSet<i32>>();
+        assert_eq!(l, r);
+    }
+
+    #[test]
+    fn test_example1() {
+        let nums1 = vec![1, 2, 2, 1];
+        let nums2 = vec![2, 2];
+        let expected = vec![2];
+        assert_equal(Solution::intersection(nums1, nums2), expected);
+    }
+
+    #[test]
+    fn test_example2() {
+        let nums1 = vec![4, 9, 5];
+        let nums2 = vec![9, 4, 9, 8, 4];
+        let expected = vec![9, 4];
+        assert_equal(Solution::intersection(nums1, nums2), expected);
+    }
+}