Add intersection of arrays

Author: sudheerj

README.md

@@ -64,7 +64,8 @@ List of Programs related to data structures and algorithms
 | 23  | Disappeared numbers                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/23.disappearedNumbers/disappearedNumbers.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/23.disappearedNumbers/disappearedNumbers.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/23.disappearedNumbers/disappearedNumbers.md)        | Easy | Array traversal |
 | 24  | Identical pairs                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/24.identicalPairs/identicalPairs.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/24.identicalPairs/identicalPairs.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/24.identicalPairs/identicalPairs.md)        | Easy | Array traversal & map |
 | 25  | Destination City                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/25.destinationCity/destinationCity.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/25.destinationCity/destinationCity.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/25.destinationCity/destinationCity.md)        | Easy | Array traversal & set |
-| 26  | Set mismatch                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/26.setMismatch/setMismatch.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/25.setMismatch/setMismatch.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/26.setMismatch/setMismatch.md)        | Easy | Array traversal & marking numbers |
+| 26  | Set mismatch                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/26.setMismatch/setMismatch.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/26.setMismatch/setMismatch.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/26.setMismatch/setMismatch.md)        | Easy | Array traversal & marking numbers |
+| 27  | Intersection of arrays                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/27.intersectionOfArrays/intersectionOfArrays.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/27.intersectionOfArrays/intersectionOfArrays.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/27.intersectionOfArrays/intersectionOfArrays.md)        | Easy | Set and array traversal |
 
 ### String
 

src/java1/algorithms/array/intersectionOfArrays/IntersectionOfArrays.java

@@ -0,0 +1,33 @@
+package java1.algorithms.array.intersectionOfArrays;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class IntersectionOfArrays {
+    private static List<Integer> intersection(int[] nums1, int[] nums2){
+        Set<Integer> set = new HashSet<>();
+        List<Integer> result = new ArrayList<>();
+
+        for (Integer num : nums1) {
+            set.add(num);
+        }
+
+        for (Integer num : nums2) {
+            if(set.contains(num)) {
+                result.add(num);
+                set.remove(num);
+            }
+        }
+
+        return result;    
+    }
+
+    public static void main(String[] args) {
+        int[] nums1 = new int[]{5,3,3,5}, nums2 = new int[]{5,3};
+        int[] nums3 = new int[]{1, 3, 5}, nums4 = new int[]{2,4};
+        System.out.println(intersection(nums1, nums2));
+        System.out.println(intersection(nums3, nums4));
+    }
+}

src/java1/algorithms/array/intersectionOfArrays/IntersectionOfArrays.md

@@ -0,0 +1,33 @@
+**Description:**
+Given two integer arrays `nums1` and `nums2`, return an array of their intersection in such away that each element in the result must be unique.
+
+**Note:** The elements in result can appear in any order.
+
+### Examples
+Example 1:
+
+Input: nums1 = [5,3,3,5], nums2 = [5,3]
+Output: [ 5, 3 ]
+
+Example 2:
+
+Input: nums1 = [1, 3, 5], nums2 = [2, 4]
+Output: [ ]
+
+**Algorithmic Steps**
+This problem is solved with the help of set data structure and array traversal over the elements. The algorithmic approach can be summarized as follows:
+
+1. Create a function named `intersection`, which accepts input arrays(`nums1` and `nums2`) to find the intersection of elements.
+   
+2. Define a set data structure named `set` which stores the elements of `nums1`. Create a result list(`result`) to return the intersection of elements.
+   
+3. Iterate over first array(`nums1`) and add each element to a set.
+   
+4. Iterate over second array(`nums2`) and add an element to result list if that element exists in a set. Also, remove the same element from set to avoid adding duplicate elements to result list.
+   
+5. Return the result array which has intersection of elements.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n1+n2)`, where `n1` is the number of elements in first array and `n2` is the number of elements in second array. This is because we need to iterate over all the elements of first array to insert them into a set with a time complexity of `O(n1)`. At the same time, we need to iterate over each element of second array to find the intersected elements. Hence, total time complexity is `O(n1+n2)`.
+ 
+It takes constant time complexity of `O(n1+n2)`. This is due to hash set usage with a space complexity of `O(n1)`and `O(min(n1+n2))` if all the elements of one array exists in another array.

src/javascript/algorithms/array/27.intersectionOfArrays/intersectionOfArrays.js

@@ -0,0 +1,18 @@
+function intersection(nums1, nums2) {
+    const set = new Set(nums1);
+    const result = [];
+
+    for (const num of nums2) {
+        if(set.has(num)) {
+            result.push(num);
+            set.delete(num);
+        }
+    }
+
+    return result;
+}
+
+const nums1 = [5,3,3,5], nums2 = [5,3];
+const nums3 = [1, 3, 5], nums4 = [2,4];
+console.log(intersection(nums1, nums2));
+console.log(intersection(nums3, nums4));

src/javascript/algorithms/array/27.intersectionOfArrays/intersectionOfArrays.md

@@ -0,0 +1,33 @@
+**Description:**
+Given two integer arrays `nums1` and `nums2`, return an array of their intersection in such away that each element in the result must be unique.
+
+**Note:** The elements in result can appear in any order.
+
+### Examples
+Example 1:
+
+Input: nums1 = [5,3,3,5], nums2 = [5,3]
+Output: [ 5, 3 ]
+
+Example 2:
+
+Input: nums1 = [1, 3, 5], nums2 = [2, 4]
+Output: [ ]
+
+**Algorithmic Steps**
+This problem is solved with the help of set data structure and array traversal over the elements. The algorithmic approach can be summarized as follows:
+
+1. Create a function named `intersection`, which accepts input arrays(`nums1` and `nums2`) to find the intersection of elements.
+   
+2. Define a set data structure named `set` which stores the elements of `nums1`. Create a result list(`result`) to return the intersection of elements.
+   
+3. Iterate over first array(`nums1`) and add each element to a set.
+   
+4. Iterate over second array(`nums2`) and add an element to result list if that element exists in a set. Also, remove the same element from set to avoid adding duplicate elements to result list.
+   
+5. Return the result array which has intersection of elements.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n1+n2)`, where `n1` is the number of elements in first array and `n2` is the number of elements in second array. This is because we need to iterate over all the elements of first array to insert them into a set with a time complexity of `O(n1)`. At the same time, we need to iterate over each element of second array to find the intersected elements. Hence, total time complexity is `O(n1+n2)`.
+ 
+It takes constant time complexity of `O(n1+n2)`. This is due to hash set usage with a space complexity of `O(n1)`and `O(min(n1+n2))` if all the elements of one array exists in another array.