# Find Union and Intersection of two unsorted arrays

Given two unsorted arrays that represent two sets (elements in every array are distinct), find union and intersection of two arrays.

For example, if the input arrays are:
arr1[] = {7, 1, 5, 2, 3, 6}
arr2[] = {3, 8, 6, 20, 7}
Then your program should print Union as {1, 2, 3, 5, 6, 7, 8, 20} and Intersection as {3, 6}. Note that the elements of union and intersection can be printed in any order.

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Method 1 (Naive)
Union:
1) Initialize union U as empty.
2) Copy all elements of first array to U.
3) Do following for every element x of second array:
…..a) If x is not present in first array, then copy x to U.
4) Return U.

Intersection:
1) Initialize intersection I as empty.
2) Do following for every element x of first array
…..a) If x is present in second array, then copy x to I.
4) Return I.

Time complexity of this method is O(mn) for both operations. Here m and n are number of elements in arr1[] and arr2[] respectively.

Method 2 (Use Sorting)
1) Sort arr1[] and arr2[]. This step takes O(mLogm + nLogn) time.
2) Use O(m + n) algorithms to find union and intersection of two sorted arrays.

Overall time complexity of this method is O(mLogm + nLogn).

Method 3 (Use Sorting and Searching)
Union:
1) Initialize union U as empty.
2) Find smaller of m and n and sort the smaller array.
3) Copy the smaller array to U.
4) For every element x of larger array, do following
…….b) Binary Search x in smaller array. If x is not present, then copy it to U.
5) Return U.

Intersection:
1) Initialize intersection I as empty.
2) Find smaller of m and n and sort the smaller array.
3) For every element x of larger array, do following
…….b) Binary Search x in smaller array. If x is present, then copy it to I.
4) Return I.

Time complexity of this method is min(mLogm + nLogm, mLogn + nLogn) which can also be written as O((m+n)Logm, (m+n)Logn). This approach works much better than the previous approach when difference between sizes of two arrays is significant.

Thanks to use_the_force for suggesting this method in a comment here.

Below is the implementation of this method.

## C++

 `// A C++ program to print union and intersection  ` `/// of two unsorted arrays ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `int` `binarySearch(``int` `arr[], ``int` `l, ``int` `r, ``int` `x); ` ` `  `// Prints union of arr1[0..m-1] and arr2[0..n-1] ` `void` `printUnion(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n) ` `{ ` `    ``// Before finding union, make sure arr1[0..m-1]  ` `    ``// is smaller ` `    ``if` `(m > n) ` `    ``{ ` `        ``int` `*tempp = arr1; ` `        ``arr1 = arr2; ` `        ``arr2 = tempp; ` ` `  `        ``int` `temp = m; ` `        ``m = n; ` `        ``n = temp; ` `    ``} ` ` `  `    ``// Now arr1[] is smaller ` ` `  `    ``// Sort the first array and print its elements (these two ` `    ``// steps can be swapped as order in output is not important) ` `    ``sort(arr1, arr1 + m); ` `    ``for` `(``int` `i=0; i n) ` `    ``{ ` `        ``int` `*tempp = arr1; ` `        ``arr1 = arr2; ` `        ``arr2 = tempp; ` ` `  `        ``int` `temp = m; ` `        ``m = n; ` `        ``n = temp; ` `    ``} ` ` `  `    ``// Now arr1[] is smaller ` ` `  `    ``// Sort smaller array arr1[0..m-1] ` `    ``sort(arr1, arr1 + m); ` ` `  `    ``// Search every element of bigger array in smaller ` `    ``// array and print the element if found ` `    ``for` `(``int` `i=0; i= l) ` `    ``{ ` `        ``int` `mid = l + (r - l)/2; ` ` `  `        ``// If the element is present at the middle itself ` `        ``if` `(arr[mid] == x)  ``return` `mid; ` ` `  `        ``// If element is smaller than mid, then it can only ` `        ``// be presen in left subarray ` `        ``if` `(arr[mid] > x)  ` `          ``return` `binarySearch(arr, l, mid-1, x); ` ` `  `        ``// Else the element can only be present in right subarray ` `        ``return` `binarySearch(arr, mid+1, r, x); ` `    ``} ` ` `  `    ``// We reach here when element is not present in array ` `    ``return` `-1; ` `} ` ` `  `/* Driver program to test above function */` `int` `main() ` `{ ` `    ``int` `arr1[] = {7, 1, 5, 2, 3, 6}; ` `    ``int` `arr2[] = {3, 8, 6, 20, 7}; ` `    ``int` `m = ``sizeof``(arr1)/``sizeof``(arr1); ` `    ``int` `n = ``sizeof``(arr2)/``sizeof``(arr2); ` `    ``cout << ``"Union of two arrays is n"``; ` `    ``printUnion(arr1, arr2, m, n); ` `    ``cout << ``"nIntersection of two arrays is n"``; ` `    ``printIntersection(arr1, arr2, m, n); ` `    ``return` `0; ` `} `

## Java

 `// A Java program to print union and intersection  ` `/// of two unsorted arrays ` `import` `java.util.Arrays; ` ` `  `class` `UnionAndIntersection  ` `{ ` `    ``// Prints union of arr1[0..m-1] and arr2[0..n-1] ` `    ``void` `printUnion(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n)  ` `    ``{ ` `        ``// Before finding union, make sure arr1[0..m-1]  ` `        ``// is smaller ` `        ``if` `(m > n)  ` `        ``{ ` `            ``int` `tempp[] = arr1; ` `            ``arr1 = arr2; ` `            ``arr2 = tempp; ` ` `  `            ``int` `temp = m; ` `            ``m = n; ` `            ``n = temp; ` `        ``} ` ` `  `        ``// Now arr1[] is smaller ` `        ``// Sort the first array and print its elements (these two ` `        ``// steps can be swapped as order in output is not important) ` `        ``Arrays.sort(arr1); ` `        ``for` `(``int` `i = ``0``; i < m; i++) ` `            ``System.out.print(arr1[i] + ``" "``); ` ` `  `        ``// Search every element of bigger array in smaller array ` `        ``// and print the element if not found ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `        ``{ ` `            ``if` `(binarySearch(arr1, ``0``, m - ``1``, arr2[i]) == -``1``) ` `                ``System.out.print(arr2[i] + ``" "``); ` `        ``} ` `    ``} ` ` `  `    ``// Prints intersection of arr1[0..m-1] and arr2[0..n-1] ` `    ``void` `printIntersection(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n)  ` `    ``{ ` `        ``// Before finding intersection, make sure arr1[0..m-1]  ` `        ``// is smaller ` `        ``if` `(m > n)  ` `        ``{ ` `            ``int` `tempp[] = arr1; ` `            ``arr1 = arr2; ` `            ``arr2 = tempp; ` ` `  `            ``int` `temp = m; ` `            ``m = n; ` `            ``n = temp; ` `        ``} ` ` `  `        ``// Now arr1[] is smaller ` `        ``// Sort smaller array arr1[0..m-1] ` `        ``Arrays.sort(arr1); ` ` `  `        ``// Search every element of bigger array in smaller array ` `        ``// and print the element if found ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `        ``{ ` `            ``if` `(binarySearch(arr1, ``0``, m - ``1``, arr2[i]) != -``1``)  ` `                ``System.out.print(arr2[i] + ``" "``); ` `        ``} ` `    ``} ` ` `  `    ``// A recursive binary search function. It returns location of x in ` `    ``// given array arr[l..r] is present, otherwise -1 ` `    ``int` `binarySearch(``int` `arr[], ``int` `l, ``int` `r, ``int` `x)  ` `    ``{ ` `        ``if` `(r >= l)  ` `        ``{ ` `            ``int` `mid = l + (r - l) / ``2``; ` ` `  `            ``// If the element is present at the middle itself ` `            ``if` `(arr[mid] == x) ` `                ``return` `mid; ` ` `  `            ``// If element is smaller than mid, then it can only  ` `            ``// be present in left subarray ` `            ``if` `(arr[mid] > x) ` `                ``return` `binarySearch(arr, l, mid - ``1``, x); ` ` `  `            ``// Else the element can only be present in right subarray ` `            ``return` `binarySearch(arr, mid + ``1``, r, x); ` `        ``} ` ` `  `        ``// We reach here when element is not present in array ` `        ``return` `-``1``; ` `    ``} ` ` `  `    ``// Driver program to test above functions ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``UnionAndIntersection u_i = ``new` `UnionAndIntersection(); ` `        ``int` `arr1[] = {``7``, ``1``, ``5``, ``2``, ``3``, ``6``}; ` `        ``int` `arr2[] = {``3``, ``8``, ``6``, ``20``, ``7``}; ` `        ``int` `m = arr1.length; ` `        ``int` `n = arr2.length; ` `        ``System.out.println(``"Union of two arrays is "``); ` `        ``u_i.printUnion(arr1, arr2, m, n); ` `        ``System.out.println(``""``); ` `        ``System.out.println(``"Intersection of two arrays is "``); ` `        ``u_i.printIntersection(arr1, arr2, m, n); ` `    ``} ` `} `

## Python3

 `# A Python3 program to print union and intersection  ` `# of two unsorted arrays ` ` `  `# Prints union of arr1[0..m-1] and arr2[0..n-1] ` `def` `printUnion(arr1, arr2, m, n): ` ` `  `    ``# Before finding union, make sure arr1[0..m-1]  ` `    ``# is smaller ` `    ``if` `(m > n): ` `        ``tempp ``=` `arr1; ` `        ``arr1 ``=` `arr2; ` `        ``arr2 ``=` `tempp; ` ` `  `        ``temp ``=` `m; ` `        ``m ``=` `n; ` `        ``n ``=` `temp; ` ` `  `    ``# Now arr1[] is smaller ` ` `  `    ``# Sort the first array and print its elements (these two ` `    ``# steps can be swapped as order in output is not important) ` `    ``arr1.sort(); ` `    ``for` `i ``in` `range``(``0``,m): ` `        ``print``(arr1[i],end``=``" "``); ` ` `  `    ``# Search every element of bigger array in smaller array ` `    ``# and print the element if not found ` `    ``for` `i ``in` `range``(``0``,n): ` `        ``if` `(binarySearch(arr1, ``0``, m ``-` `1``, arr2[i]) ``=``=` `-``1``): ` `            ``print``(arr2[i],end``=``" "``); ` ` `  `# Prints intersection of arr1[0..m-1] and arr2[0..n-1] ` `def` `printIntersection(arr1, arr2, m, n): ` ` `  `    ``# Before finding intersection, make sure arr1[0..m-1]  ` `    ``# is smaller ` `    ``if` `(m > n): ` `        ``tempp ``=` `arr1; ` `        ``arr1 ``=` `arr2; ` `        ``arr2 ``=` `tempp; ` ` `  `        ``temp ``=` `m; ` `        ``m ``=` `n; ` `        ``n ``=` `temp; ` ` `  `    ``# Now arr1[] is smaller ` ` `  `    ``# Sort smaller array arr1[0..m-1] ` `    ``arr1.sort(); ` ` `  `    ``# Search every element of bigger array in smaller ` `    ``# array and print the element if found ` `    ``for` `i ``in` `range``(``0``,n): ` `        ``if` `(binarySearch(arr1, ``0``, m ``-` `1``, arr2[i]) !``=` `-``1``): ` `            ``print``(arr2[i],end``=``" "``); ` ` `  `# A recursive binary search function. It returns  ` `# location of x in given array arr[l..r] is present,  ` `# otherwise -1 ` `def` `binarySearch(arr, l, r,x): ` ` `  `    ``if` `(r >``=` `l): ` `        ``mid ``=` `int``(l ``+` `(r ``-` `l)``/``2``); ` ` `  `        ``# If the element is present at the middle itself ` `        ``if` `(arr[mid] ``=``=` `x): ` `            ``return` `mid; ` ` `  `        ``# If element is smaller than mid, then it can only ` `        ``# be presen in left subarray ` `        ``if` `(arr[mid] > x): ` `            ``return` `binarySearch(arr, l, mid ``-` `1``, x); ` ` `  `        ``# Else the element can only be present in right subarray ` `        ``return` `binarySearch(arr, mid ``+` `1``, r, x); ` ` `  `    ``# We reach here when element is not present in array ` `    ``return` `-``1``; ` ` `  `# Driver program to test above function  ` `arr1 ``=` `[``7``, ``1``, ``5``, ``2``, ``3``, ``6``]; ` `arr2 ``=` `[``3``, ``8``, ``6``, ``20``, ``7``]; ` `m ``=` `len``(arr1); ` `n ``=` `len``(arr2); ` `print``(``"Union of two arrays is "``); ` `printUnion(arr1, arr2, m, n); ` `print``(``"\nIntersection of two arrays is "``); ` `printIntersection(arr1, arr2, m, n); ` ` `  `# This code is contributed by mits `

## C#

 `// A C# program to print union and  ` `// intersection of two unsorted arrays ` `using` `System; ` ` `  `class` `GFG ` `{ ` `// Prints union of arr1[0..m-1] and arr2[0..n-1] ` `static` `void` `printUnion(``int` `[]arr1, ``int` `[]arr2, ` `                                   ``int` `m, ``int` `n)  ` `{ ` `    ``// Before finding union, make  ` `    ``// sure arr1[0..m-1] is smaller ` `    ``if` `(m > n)  ` `    ``{ ` `        ``int` `[]tempp = arr1; ` `        ``arr1 = arr2; ` `        ``arr2 = tempp; ` ` `  `        ``int` `temp = m; ` `        ``m = n; ` `        ``n = temp; ` `    ``} ` ` `  `    ``// Now arr1[] is smaller ` `    ``// Sort the first array and print ` `    ``// its elements (these two steps can ` `    ``// be swapped as order in output is  ` `    ``// not important) ` `    ``Array.Sort(arr1); ` `    ``for` `(``int` `i = 0; i < m; i++) ` `        ``Console.Write(arr1[i] + ``" "``); ` ` `  `    ``// Search every element of bigger  ` `    ``// array in smaller array and print  ` `    ``// the element if not found ` `    ``for` `(``int` `i = 0; i < n; i++)  ` `    ``{ ` `        ``if` `(binarySearch(arr1, 0, m - 1,  ` `                         ``arr2[i]) == -1) ` `            ``Console.Write(arr2[i] + ``" "``); ` `    ``} ` `} ` ` `  `// Prints intersection of arr1[0..m-1]  ` `// and arr2[0..n-1] ` `static` `void` `printIntersection(``int` `[]arr1, ` `                              ``int` `[]arr2,  ` `                              ``int` `m, ``int` `n)  ` `{ ` `    ``// Before finding intersection,  ` `    ``// make sure arr1[0..m-1] is smaller ` `    ``if` `(m > n)  ` `    ``{ ` `        ``int` `[]tempp = arr1; ` `        ``arr1 = arr2; ` `        ``arr2 = tempp; ` ` `  `        ``int` `temp = m; ` `        ``m = n; ` `        ``n = temp; ` `    ``} ` ` `  `    ``// Now arr1[] is smaller ` `    ``// Sort smaller array arr1[0..m-1] ` `    ``Array.Sort(arr1); ` ` `  `    ``// Search every element of bigger array in  ` `    ``// smaller array and print the element if found ` `    ``for` `(``int` `i = 0; i < n; i++)  ` `    ``{ ` `        ``if` `(binarySearch(arr1, 0, m - 1, arr2[i]) != -1)  ` `            ``Console.Write(arr2[i] + ``" "``); ` `    ``} ` `} ` ` `  `// A recursive binary search function.  ` `// It returns location of x in given  ` `// array arr[l..r] is present, otherwise -1 ` `static` `int` `binarySearch(``int` `[]arr, ``int` `l,  ` `                        ``int` `r, ``int` `x)  ` `{ ` `    ``if` `(r >= l)  ` `    ``{ ` `        ``int` `mid = l + (r - l) / 2; ` ` `  `        ``// If the element is present at ` `        ``// the middle itself ` `        ``if` `(arr[mid] == x) ` `            ``return` `mid; ` ` `  `        ``// If element is smaller than mid, then it  ` `        ``// can only be present in left subarray ` `        ``if` `(arr[mid] > x) ` `            ``return` `binarySearch(arr, l, mid - 1, x); ` ` `  `        ``// Else the element can only be  ` `        ``// present in right subarray ` `        ``return` `binarySearch(arr, mid + 1, r, x); ` `    ``} ` ` `  `    ``// We reach here when element is ` `    ``// not present in array ` `    ``return` `-1; ` `} ` ` `  `// Driver Code ` `static` `public` `void` `Main () ` `{ ` `    ``int` `[]arr1 = {7, 1, 5, 2, 3, 6}; ` `    ``int` `[]arr2 = {3, 8, 6, 20, 7}; ` `    ``int` `m = arr1.Length; ` `    ``int` `n = arr2.Length; ` `    ``Console.WriteLine(``"Union of two arrays is "``); ` `    ``printUnion(arr1, arr2, m, n); ` `    ``Console.WriteLine(``""``); ` `    ``Console.WriteLine(``"Intersection of two arrays is "``); ` `    ``printIntersection(arr1, arr2, m, n); ` `} ` `} ` ` `  `// This code is contributed  ` `// by Sach_Code `

## PHP

 ` ``\$n``) ` `    ``{ ` `        ``\$tempp` `= ``\$arr1``; ` `        ``\$arr1` `= ``\$arr2``; ` `        ``\$arr2` `= ``\$tempp``; ` ` `  `        ``\$temp` `= ``\$m``; ` `        ``\$m` `= ``\$n``; ` `        ``\$n` `= ``\$temp``; ` `    ``} ` ` `  `    ``// Now arr1[] is smaller ` ` `  `    ``// Sort the first array and print its elements (these two ` `    ``// steps can be swapped as order in output is not important) ` `    ``sort(``\$arr1``); ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$m``; ``\$i``++) ` `        ``echo` `\$arr1``[``\$i``].``" "``; ` ` `  `    ``// Search every element of bigger array in smaller array ` `    ``// and print the element if not found ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++) ` `        ``if` `(binarySearch(``\$arr1``, 0, ``\$m` `- 1, ``\$arr2``[``\$i``]) == -1) ` `            ``echo` `\$arr2``[``\$i``].``" "``; ` `} ` ` `  `// Prints intersection of arr1[0..m-1] and arr2[0..n-1] ` `function` `printIntersection(``\$arr1``, ``\$arr2``, ``\$m``, ``\$n``) ` `{ ` `    ``// Before finding intersection, make sure arr1[0..m-1]  ` `    ``// is smaller ` `    ``if` `(``\$m` `> ``\$n``) ` `    ``{ ` `        ``\$tempp` `= ``\$arr1``; ` `        ``\$arr1` `= ``\$arr2``; ` `        ``\$arr2` `= ``\$tempp``; ` ` `  `        ``\$temp` `= ``\$m``; ` `        ``\$m` `= ``\$n``; ` `        ``\$n` `= ``\$temp``; ` `    ``} ` ` `  `    ``// Now arr1[] is smaller ` ` `  `    ``// Sort smaller array arr1[0..m-1] ` `    ``sort(``\$arr1``); ` ` `  `    ``// Search every element of bigger array in smaller ` `    ``// array and print the element if found ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++) ` `        ``if` `(binarySearch(``\$arr1``, 0, ``\$m` `- 1, ``\$arr2``[``\$i``]) != -1) ` `            ``echo` `\$arr2``[``\$i``].``" "``; ` `} ` ` `  `// A recursive binary search function. It returns  ` `// location of x in given array arr[l..r] is present,  ` `// otherwise -1 ` `function` `binarySearch(``\$arr``, ``\$l``, ``\$r``,``\$x``) ` `{ ` `    ``if` `(``\$r` `>= ``\$l``) ` `    ``{ ` `        ``\$mid` `= (int)(``\$l` `+ (``\$r` `- ``\$l``)/2); ` ` `  `        ``// If the element is present at the middle itself ` `        ``if` `(``\$arr``[``\$mid``] == ``\$x``) ``return` `\$mid``; ` ` `  `        ``// If element is smaller than mid, then it can only ` `        ``// be presen in left subarray ` `        ``if` `(``\$arr``[``\$mid``] > ``\$x``)  ` `        ``return` `binarySearch(``\$arr``, ``\$l``, ``\$mid` `- 1, ``\$x``); ` ` `  `        ``// Else the element can only be present in right subarray ` `        ``return` `binarySearch(``\$arr``, ``\$mid` `+ 1, ``\$r``, ``\$x``); ` `    ``} ` ` `  `    ``// We reach here when element is not present in array ` `    ``return` `-1; ` `} ` ` `  `/* Driver program to test above function */` `    ``\$arr1` `= ``array``(7, 1, 5, 2, 3, 6); ` `    ``\$arr2` `= ``array``(3, 8, 6, 20, 7); ` `    ``\$m` `= ``count``(``\$arr1``); ` `    ``\$n` `= ``count``(``\$arr2``); ` `    ``echo` `"Union of two arrays is \n"``; ` `    ``printUnion(``\$arr1``, ``\$arr2``, ``\$m``, ``\$n``); ` `    ``echo` `"\nIntersection of two arrays is \n"``; ` `    ``printIntersection(``\$arr1``, ``\$arr2``, ``\$m``, ``\$n``); ` ` `  `// This code is contributed by mits ` `?> `

Output:

```Union of two arrays is
3 6 7 8 20 1 5 2
Intersection of two arrays is
7 3 6```

Another Approach (When elements in the array may not be distinct) :

## C

 `// C code to find intersection when ` `// elements may not be distinct ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// Function to find intersection ` `void` `intersection(``int` `a[], ``int` `b[], ``int` `n, ``int` `m) ` `{ ` `    ``int` `i = 0, j = 0; ` `     `  `    ``while` `(i < n && j < m)  ` `    ``{ ` `                 `  `        ``if` `(a[i] > b[j])  ` `        ``{ ` `            ``j++; ` `        ``}  ` `                 `  `        ``else`  `        ``if` `(b[j] > a[i])  ` `        ``{ ` `            ``i++; ` `        ``}  ` `        ``else`  `        ``{ ` `            ``// when both are equal ` `            ``cout << a[i] << ``" "``; ` `            ``i++; ` `            ``j++; ` `        ``} ` `    ``} ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `a[] = {1, 2, 3, 3, 4, 5, 5, 6}; ` `    ``int` `b[] = {3, 3, 5}; ` `     `  `    ``int` `n = ``sizeof``(a)/``sizeof``(a); ` `    ``int` `m = ``sizeof``(b)/``sizeof``(b); ` `    ``intersection(a, b, n, m); ` `} `

## Java

 `// Java code to find intersection when ` `// elements may not be distinct ` ` `  `import` `java.io.*; ` ` `  `class` `GFG { ` `     `  `// Function to find intersection ` `static` `void` `intersection(``int` `a[], ``int` `b[], ``int` `n, ``int` `m) ` `{ ` `    ``int` `i = ``0``, j = ``0``; ` `     `  `    ``while` `(i < n && j < m)  ` `    ``{ ` `                 `  `        ``if` `(a[i] > b[j])  ` `        ``{ ` `            ``j++; ` `        ``}  ` `                 `  `        ``else` `        ``if` `(b[j] > a[i])  ` `        ``{ ` `            ``i++; ` `        ``}  ` `        ``else` `        ``{ ` `            ``// when both are equal ` `            ``System.out.print(a[i] + ``" "``); ` `            ``i++; ` `            ``j++; ` `        ``} ` `    ``} ` `} ` ` `  `// Driver Code ` `    ``public` `static` `void` `main (String[] args) { ` `    ``int` `a[] = {``1``, ``2``, ``3``, ``3``, ``4``, ``5``, ``5``, ``6``}; ` `    ``int` `b[] = {``3``, ``3``, ``5``}; ` `     `  `    ``int` `n = a.length; ` `    ``int` `m = b.length; ` `    ``intersection(a, b, n, m); ` `    ``} ` `} `

## Python 3

 `# Python 3 code to find intersection  ` `# when elements may not be distinct ` ` `  `# Function to find intersection ` `def` `intersection(a, b, n, m): ` ` `  `    ``i ``=` `0` `    ``j ``=` `0` `     `  `    ``while` `(i < n ``and` `j < m) : ` `                 `  `        ``if` `(a[i] > b[j]) : ` `            ``j ``+``=` `1` `                 `  `        ``else``: ` `            ``if` `(b[j] > a[i]) : ` `                ``i ``+``=` `1` ` `  `            ``else``: ` `                ``# when both are equal ` `                ``print``(a[i], end ``=` `" "``) ` `                ``i ``+``=` `1` `                ``j ``+``=` `1` ` `  `# Driver Code ` `if` `__name__ ``=``=``"__main__"``: ` `     `  `    ``a ``=` `[``1``, ``2``, ``3``, ``3``, ``4``, ``5``, ``5``, ``6``] ` `    ``b ``=` `[``3``, ``3``, ``5``] ` `     `  `    ``n ``=` `len``(a) ` `    ``m ``=` `len``(b) ` `    ``intersection(a, b, n, m) ` ` `  `# This code is contributed by Ita_c `

## C#

 `// C# code to find intersection when ` `// elements may not be distinct ` ` `  `using` `System; ` ` `  `class` `GFG { ` `     `  `// Function to find intersection ` `static` `void` `intersection(``int``[] a, ``int``[] b, ``int` `n, ``int` `m) ` `{ ` `    ``int` `i = 0, j = 0; ` `     `  `    ``while` `(i < n && j < m)  ` `    ``{ ` `                 `  `        ``if` `(a[i] > b[j])  ` `        ``{ ` `            ``j++; ` `        ``}  ` `                 `  `        ``else` `        ``if` `(b[j] > a[i])  ` `        ``{ ` `            ``i++; ` `        ``}  ` `        ``else` `        ``{ ` `            ``// when both are equal ` `            ``Console.Write(a[i] + ``" "``); ` `            ``i++; ` `            ``j++; ` `        ``} ` `    ``} ` `} ` ` `  `// Driver Code ` `    ``public` `static` `void` `Main () { ` `    ``int``[] a = {1, 2, 3, 3, 4, 5, 5, 6}; ` `    ``int``[] b = {3, 3, 5}; ` `     `  `    ``int` `n = a.Length; ` `    ``int` `m = b.Length; ` `    ``intersection(a, b, n, m); ` `    ``} ` `} ` `// this code is contributed by mukul singh `

## PHP

 ` ``\$b``[``\$j``])  ` `        ``{ ` `            ``\$j``++; ` `        ``}  ` `                 `  `        ``else` `        ``if` `(``\$b``[``\$j``] > ``\$a``[``\$i``])  ` `        ``{ ` `            ``\$i``++; ` `        ``}  ` `        ``else` `        ``{ ` `            ``// when both are equal ` `            ``echo``(``\$a``[``\$i``] . ``" "``); ` `            ``\$i``++; ` `            ``\$j``++; ` `        ``} ` `    ``} ` `} ` ` `  `// Driver Code ` `\$a` `= ``array``(1, 2, 3, 3, 4, 5, 5, 6); ` `\$b` `= ``array``(3, 3, 5); ` ` `  `\$n` `= sizeof(``\$a``); ` `\$m` `= sizeof(``\$b``); ` `intersection(``\$a``, ``\$b``, ``\$n``, ``\$m``); ` ` `  `// This code is contributed  ` `// by Mukul Singh ` `?> `

Output :

`3 3 5`

Thanks Sanny Kumar for suggesting the above method.

Method 4 (Use Hashing)
Union:
Union
1. Initialize an empty hash set hs.
2. Iterate through the first array and put every element of the first array in the set S.
3. Repeat the process for the second array.
4. Print the set hs.

Intersection
1. Initialize an empty set hs.
2. Iterate through the first array and put every element of the first array in the set S.
3. For every element x of the second array, do the following :
Search x in the set hs. If x is present, then print it.

Time complexity of this method is Θ(m+n) under the assumption that hash table search and insert operations take Θ(1) time.

## C++

 `// CPP program to find union and intersection ` `// using sets ` `#include ` `using` `namespace` `std; ` ` `  `// Prints union of arr1[0..n1-1] and arr2[0..n2-1] ` `void` `printUnion(``int` `arr1[], ``int` `arr2[], ``int` `n1, ``int` `n2) ` `{ ` `    ``set<``int``> hs; ` ` `  `    ``// Inhsert the elements of arr1[] to set hs ` `    ``for` `(``int` `i = 0; i < n1; i++) ` `        ``hs.insert(arr1[i]); ` ` `  `    ``// Insert the elements of arr2[] to set hs ` `    ``for` `(``int` `i = 0; i < n2; i++) ` `        ``hs.insert(arr2[i]); ` ` `  `    ``// Print the content of set hs ` `    ``for` `(``auto` `it = hs.begin(); it != hs.end(); it++) ` `        ``cout << *it << ``" "``; ` `    ``cout << endl; ` `} ` ` `  `// Prints intersection of arr1[0..n1-1] and ` `// arr2[0..n2-1] ` `void` `printIntersection(``int` `arr1[], ``int` `arr2[], ` `                               ``int` `n1, ``int` `n2) ` `{ ` `    ``set<``int``> hs; ` ` `  `    ``// Insert the elements of arr1[] to set S ` `    ``for` `(``int` `i = 0; i < n1; i++) ` `        ``hs.insert(arr1[i]); ` ` `  `    ``for` `(``int` `i = 0; i < n2; i++) ` ` `  `        ``// If element is present in set then ` `        ``// push it to vector V ` `        ``if` `(hs.find(arr2[i]) != hs.end()) ` `            ``cout << arr2[i] << ``" "``; ` `} ` ` `  `// Driver Program ` `int` `main() ` `{ ` `    ``int` `arr1[] = { 7, 1, 5, 2, 3, 6 }; ` `    ``int` `arr2[] = { 3, 8, 6, 20, 7 }; ` `    ``int` `n1 = ``sizeof``(arr1) / ``sizeof``(arr1); ` `    ``int` `n2 = ``sizeof``(arr2) / ``sizeof``(arr2); ` `    ``printUnion(arr1, arr2, n1, n2); ` `    ``printIntersection(arr1, arr2, n1, n2); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find union and intersection ` `// using Hashing ` `import` `java.util.HashSet; ` ` `  `class` `Test ` `{    ` `    ``// Prints union of arr1[0..m-1] and arr2[0..n-1] ` `    ``static` `void` `printUnion(``int` `arr1[], ``int` `arr2[]) ` `    ``{ ` `        ``HashSet hs = ``new` `HashSet<>(); ` `         `  `        ``for` `(``int` `i = ``0``; i < arr1.length; i++)  ` `            ``hs.add(arr1[i]);         ` `        ``for` `(``int` `i = ``0``; i < arr2.length; i++)  ` `            ``hs.add(arr2[i]); ` `        ``System.out.println(hs);         ` `    ``} ` `     `  `    ``// Prints intersection of arr1[0..m-1] and arr2[0..n-1] ` `    ``static` `void` `printIntersection(``int` `arr1[], ``int` `arr2[]) ` `    ``{ ` `        ``HashSet hs = ``new` `HashSet<>(); ` `        ``HashSet hs1 = ``new` `HashSet<>(); ` `         `  `        ``for` `(``int` `i = ``0``; i < arr1.length; i++)  ` `            ``hs.add(arr1[i]); ` `         `  `        ``for` `(``int` `i = ``0``; i < arr2.length; i++)  ` `            ``if` `(hs.contains(arr2[i])) ` `               ``System.out.print(arr2[i] + ``" "``); ` `    ``} ` `     `  `    ``// Driver method to test the above function ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``int` `arr1[] = {``7``, ``1``, ``5``, ``2``, ``3``, ``6``}; ` `        ``int` `arr2[] = {``3``, ``8``, ``6``, ``20``, ``7``}; ` ` `  `        ``System.out.println(``"Union of two arrays is : "``); ` `        ``printUnion(arr1, arr2); ` `         `  `        ``System.out.println(``"Intersection of two arrays is : "``); ` `        ``printIntersection(arr1, arr2);         ` `    ``} ` `} `

## Python

 `# Python program to find union and intersection  ` `# using sets ` `def` `printUnion(arr1, arr2, n1, n2): ` `    ``hs ``=` `set``() ` `     `  `    ``# Inhsert the elements of arr1[] to set hs  ` `    ``for` `i ``in` `range``(``0``, n1): ` `        ``hs.add(arr1[i]) ` `         `  `    ``# Inhsert the elements of arr1[] to set hs  ` `    ``for` `i ``in` `range``(``0``, n2): ` `        ``hs.add(arr2[i]) ` `    ``print``(``"Union:"``) ` `    ``for` `i ``in` `hs: ` `        ``print``(i, end``=``" "``) ` `    ``print``(``"\n"``) ` `     `  `    ``# Prints intersection of arr1[0..n1-1] and  ` `    ``# arr2[0..n2-1]  ` `def` `printIntersection(arr1, arr2, n1, n2): ` `    ``hs ``=` `set``() ` `     `  `    ``# Insert the elements of arr1[] to set S  ` `    ``for` `i ``in` `range``(``0``, n1): ` `        ``hs.add(arr1[i]) ` `    ``print``(``"Intersection:"``) ` `    ``for` `i ``in` `range``(``0``,n2): ` `         `  `        ``# If element is present in set then  ` `        ``# push it to vector V ` `        ``if` `arr2[i] ``in` `hs: ` `            ``print``(arr2[i],end``=``" "``) ` `             `  `# Driver Program  ` `arr1 ``=` `[ ``7``, ``1``, ``5``, ``2``, ``3``, ``6` `]  ` `arr2 ``=` `[ ``3``, ``8``, ``6``, ``20``, ``7` `]  ` `n1 ``=` `len``(arr1) ` `n2 ``=` `len``(arr2) ` `printUnion(arr1, arr2, n1, n2)  ` `printIntersection(arr1, arr2, n1, n2)  ` `         `  `# This artice is contributed by Kumar Suman . `

## C#

 `// C# program to find union and intersection ` `// using Hashing ` `using` `System; ` `using` `System.Linq; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG ` `{  ` `    ``// Prints union of arr1[0..m-1] and arr2[0..n-1] ` `    ``static` `void` `printUnion(``int` `[]arr1, ``int` `[]arr2) ` `    ``{ ` `        ``HashSet<``int``> hs = ``new` `HashSet<``int``>(); ` `         `  `        ``for` `(``int` `i = 0; i < arr1.Length; i++)  ` `            ``hs.Add(arr1[i]);      ` `        ``for` `(``int` `i = 0; i < arr2.Length; i++)  ` `            ``hs.Add(arr2[i]); ` `     `  `            ``Console.WriteLine(``string``.Join(``", "``, hs));      ` `    ``} ` `     `  `    ``// Prints intersection of arr1[0..m-1] and arr2[0..n-1] ` `    ``static` `void` `printIntersection(``int` `[]arr1, ``int` `[]arr2) ` `    ``{ ` `        ``HashSet<``int``> hs = ``new` `HashSet<``int``>(); ` `         `  `        ``for` `(``int` `i = 0; i < arr1.Length; i++)  ` `            ``hs.Add(arr1[i]); ` `         `  `        ``for` `(``int` `i = 0; i < arr2.Length; i++)  ` `            ``if` `(hs.Contains(arr2[i])) ` `            ``Console.Write(arr2[i] + ``" "``); ` `    ``} ` `     `  `    ``// Driver Code ` `    ``static` `void` `Main()  ` `    ``{ ` `        ``int` `[]arr1 = {7, 1, 5, 2, 3, 6}; ` `        ``int` `[]arr2 = {3, 8, 6, 20, 7}; ` ` `  `        ``Console.WriteLine(``"Union of two arrays is : "``); ` `        ``printUnion(arr1, arr2); ` `     `  `        ``Console.WriteLine(``"\nIntersection of two arrays is : "``); ` `        ``printIntersection(arr1, arr2);  ` `    ``} ` `} ` ` `  `// This code is contributed by mits `

This method is contributed by Ankur Singh.

Output:

```Union of two arrays is :
[1, 2, 3, 20, 5, 6, 7, 8]
Intersection of two arrays is :
3 6 7 ```

Method 5 (Kind of hashing technique without using any predefined Java Collections)
1. Intialize array with size of m+n
2. Fill first array value in resultant array by doing hashing(to find appropriate position)
3. Repeat for second array
4. While doing hashing if collision happens increment the position in recursive way

## Java

 `// Java program to find union and intersection  ` `// using similar Hashing Technique  ` `// without using any predefined Java Collections ` `// Time Complexity best case & avg case = O(m+n) ` `// Worst case = O(nlogn) ` ` `  `//package com.arrays.math; ` ` `  `public` `class` `UnsortedIntersectionUnion { ` ` `  `        ``// Prints intersection of arr1[0..n1-1] and ` `        ``// arr2[0..n2-1] ` `    ``public` `void` `findPosition(``int` `a[], ``int` `b[]) { ` `        ``int` `v = (a.length + b.length); ` `        ``int` `ans[] = ``new` `int``[v]; ` ` `  `        ``int` `zero1 = ``0``; ` `        ``int` `zero2 = ``0``; ` ` `  `        ``System.out.print(``"Intersection : "``); ` `        ``// Iterate first array ` `        ``for` `(``int` `i = ``0``; i < a.length; i++) ` `            ``zero1 = iterateArray(a, v, ans, i); ` ` `  `        ``// Iterate second array ` `        ``for` `(``int` `j = ``0``; j < b.length; j++) ` `            ``zero2 = iterateArray(b, v, ans, j); ` ` `  `        ``int` `zero = zero1 + zero2; ` `        ``placeZeros(v, ans, zero); ` `        ``printUnion(v, ans, zero); ` ` `  `    ``} ` `     `  `    ``// Prints union of arr1[0..n1-1] and arr2[0..n2-1] ` `    ``private` `void` `printUnion(``int` `v, ``int``[] ans, ``int` `zero) { ` `        ``int` `zero1 = ``0``; ` `        ``System.out.print(``"\nUnion : "``); ` `        ``for` `(``int` `i = ``0``; i < v; i++) { ` `            ``if` `((zero == ``0` `&& ans[i] == ``0``) || (ans[i] == ``0` `&& zero1 > ``0``)) ` `                ``continue``; ` `            ``if` `(ans[i] == ``0``) ` `                ``zero1++; ` `            ``System.out.print(ans[i] + ``","``); ` `        ``} ` `    ``} ` ` `  `    ``private` `void` `placeZeros(``int` `v, ``int``[] ans, ``int` `zero) { ` `        ``if` `(zero == ``2``) { ` `            ``System.out.println(``"0"``); ` `            ``int` `d[] = { ``0` `}; ` `            ``placeValue(d, ans, ``0``, ``0``, v); ` `        ``} ` `        ``if` `(zero == ``1``) { ` `            ``int` `d[] = { ``0` `}; ` `            ``placeValue(d, ans, ``0``, ``0``, v); ` `        ``} ` `    ``} ` ` `  `    ``// Function to itreate array ` `    ``private` `int` `iterateArray(``int``[] a, ``int` `v, ``int``[] ans, ``int` `i) { ` `        ``if` `(a[i] != ``0``) { ` `            ``int` `p = a[i] % v; ` `            ``placeValue(a, ans, i, p, v); ` `        ``} ``else` `            ``return` `1``; ` `        ``return` `0``; ` `    ``} ` ` `  `    ``private` `void` `placeValue(``int``[] a, ``int``[] ans, ``int` `i, ``int` `p, ``int` `v) { ` `        ``p = p % v; ` `        ``if` `(ans[p] == ``0``) ` `            ``ans[p] = a[i]; ` `        ``else` `{ ` `            ``if` `(ans[p] == a[i]) ` `                ``System.out.print(a[i] + ``","``); ` `            ``else` `{ ` `                 `  `                ``//Hashing collision happened increment position and do recursive call ` `                ``p = p + ``1``; ` `                ``placeValue(a, ans, i, p, v); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``public` `static` `void` `main(String args[]) { ` `        ``int` `a[] = { ``7``, ``1``, ``5``, ``2``, ``3``, ``6` `}; ` `        ``int` `b[] = { ``3``, ``8``, ``6``, ``20``, ``7` `}; ` ` `  `        ``UnsortedIntersectionUnion uiu = ``new` `UnsortedIntersectionUnion(); ` `        ``uiu.findPosition(a, b); ` `    ``} ` `} ` `// This code is contributed by Mohanakrishnan S. `

## Python3

 `# Python3 program to find union and intersection  ` `# using similar Hashing Technique  ` `# without using any predefined Java Collections ` `# Time Complexity best case & avg case = O(m+n) ` `# Worst case = O(nlogn) ` ` `  ` `  `# Prints intersection of arr1[0..n1-1] and ` `# arr2[0..n2-1] ` `def` `findPosition(a, b): ` `    ``v ``=` `len``(a) ``+` `len``(b); ` `    ``ans ``=` `[``0``]``*``v; ` `    ``zero1 ``=` `zero2 ``=` `0``; ` `    ``print``(``"Intersection :"``,end``=``" "``); ` `     `  `    ``# Iterate first array ` `    ``for` `i ``in` `range``(``len``(a)): ` `        ``zero1 ``=` `iterateArray(a, v, ans, i); ` `     `  `    ``# Iterate second array ` `    ``for` `j ``in` `range``(``len``(b)): ` `        ``zero2 ``=` `iterateArray(b, v, ans, j); ` `     `  `    ``zero ``=` `zero1 ``+` `zero2; ` `    ``placeZeros(v, ans, zero); ` `    ``printUnion(v, ans, zero); ` `     `  `# Prints union of arr1[0..n1-1] and arr2[0..n2-1] ` `def` `printUnion(v, ans,zero): ` `    ``zero1 ``=` `0``; ` `    ``print``(``"\nUnion :"``,end``=``" "``); ` `    ``for` `i ``in` `range``(v): ` `        ``if` `((zero ``=``=` `0` `and` `ans[i] ``=``=` `0``) ``or` `            ``(ans[i] ``=``=` `0` `and` `zero1 > ``0``)): ` `            ``continue``; ` `        ``if` `(ans[i] ``=``=` `0``): ` `            ``zero1``+``=``1``; ` `        ``print``(ans[i],end``=``","``); ` ` `  `def` `placeZeros(v, ans, zero): ` `    ``if` `(zero ``=``=` `2``): ` `        ``print``(``"0"``); ` `        ``d ``=` `[``0``]; ` `        ``placeValue(d, ans, ``0``, ``0``, v); ` `    ``if` `(zero ``=``=` `1``): ` `        ``d``=``[``0``]; ` `        ``placeValue(d, ans, ``0``, ``0``, v); ` ` `  `# Function to itreate array ` `def` `iterateArray(a,v,ans,i): ` `    ``if` `(a[i] !``=` `0``): ` `        ``p ``=` `a[i] ``%` `v; ` `        ``placeValue(a, ans, i, p, v); ` `    ``else``: ` `        ``return` `1``; ` `     `  `    ``return` `0``; ` ` `  `def` `placeValue(a,ans,i,p,v): ` `    ``p ``=` `p ``%` `v; ` `    ``if` `(ans[p] ``=``=` `0``): ` `        ``ans[p] ``=` `a[i]; ` `    ``else``: ` `        ``if` `(ans[p] ``=``=` `a[i]): ` `            ``print``(a[i],end``=``","``); ` `        ``else``: ` `            ``# Hashing collision happened increment  ` `            ``# position and do recursive call ` `            ``p ``=` `p ``+` `1``; ` `            ``placeValue(a, ans, i, p, v); ` ` `  `# Driver code ` `a ``=` `[ ``7``, ``1``, ``5``, ``2``, ``3``, ``6` `]; ` `b ``=` `[ ``3``, ``8``, ``6``, ``20``, ``7` `]; ` `findPosition(a, b); ` ` `  `# This code is contributed by mits `

## C#

 `// C# program to find union and intersection  ` `// using similar Hashing Technique  ` `// without using any predefined Java Collections ` `// Time Complexity best case & avg case = O(m+n) ` `// Worst case = O(nlogn) ` ` `  `//package com.arrays.math; ` `using` `System; ` `class` `UnsortedIntersectionUnion  ` `{ ` ` `  `        ``// Prints intersection of arr1[0..n1-1] and ` `        ``// arr2[0..n2-1] ` `    ``public` `void` `findPosition(``int` `[]a, ``int` `[]b) ` `    ``{ ` `        ``int` `v = (a.Length + b.Length); ` `        ``int` `[]ans = ``new` `int``[v]; ` ` `  `        ``int` `zero1 = 0; ` `        ``int` `zero2 = 0; ` ` `  `        ``Console.Write(``"Intersection : "``); ` `         `  `        ``// Iterate first array ` `        ``for` `(``int` `i = 0; i < a.Length; i++) ` `            ``zero1 = iterateArray(a, v, ans, i); ` ` `  `        ``// Iterate second array ` `        ``for` `(``int` `j = 0; j < b.Length; j++) ` `            ``zero2 = iterateArray(b, v, ans, j); ` ` `  `        ``int` `zero = zero1 + zero2; ` `        ``placeZeros(v, ans, zero); ` `        ``printUnion(v, ans, zero); ` ` `  `    ``} ` `     `  `    ``// Prints union of arr1[0..n1-1]  ` `    ``// and arr2[0..n2-1] ` `    ``private` `void` `printUnion(``int` `v, ``int``[] ans, ``int` `zero) ` `    ``{ ` `        ``int` `zero1 = 0; ` `        ``Console.Write(``"\nUnion : "``); ` `        ``for` `(``int` `i = 0; i < v; i++)  ` `        ``{ ` `            ``if` `((zero == 0 && ans[i] == 0) ||  ` `                    ``(ans[i] == 0 && zero1 > 0)) ` `                ``continue``; ` `            ``if` `(ans[i] == 0) ` `                ``zero1++; ` `            ``Console.Write(ans[i] + ``","``); ` `        ``} ` `    ``} ` ` `  `    ``private` `void` `placeZeros(``int` `v, ``int``[] ans, ``int` `zero) ` `    ``{ ` `        ``if` `(zero == 2)  ` `        ``{ ` `            ``Console.WriteLine(``"0"``); ` `            ``int` `[]d = { 0 }; ` `            ``placeValue(d, ans, 0, 0, v); ` `        ``} ` `        ``if` `(zero == 1)  ` `        ``{ ` `            ``int` `[]d = { 0 }; ` `            ``placeValue(d, ans, 0, 0, v); ` `        ``} ` `    ``} ` ` `  `    ``// Function to itreate array ` `    ``private` `int` `iterateArray(``int``[] a, ``int` `v,  ` `                            ``int``[] ans, ``int` `i) ` `    ``{ ` `        ``if` `(a[i] != 0)  ` `        ``{ ` `            ``int` `p = a[i] % v; ` `            ``placeValue(a, ans, i, p, v); ` `        ``} ``else` `            ``return` `1; ` `        ``return` `0; ` `    ``} ` ` `  `    ``private` `void` `placeValue(``int``[] a, ``int``[] ans,  ` `                                ``int` `i, ``int` `p, ``int` `v)  ` `    ``{ ` `        ``p = p % v; ` `        ``if` `(ans[p] == 0) ` `            ``ans[p] = a[i]; ` `        ``else` `{ ` `            ``if` `(ans[p] == a[i]) ` `                ``Console.Write(a[i] + ``","``); ` `            ``else` `            ``{ ` `                 `  `                ``//Hashing collision happened increment  ` `                ``// position and do recursive call ` `                ``p = p + 1; ` `                ``placeValue(a, ans, i, p, v); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main()  ` `    ``{ ` `        ``int` `[]a = { 7, 1, 5, 2, 3, 6 }; ` `        ``int` `[]b = { 3, 8, 6, 20, 7 }; ` ` `  `        ``UnsortedIntersectionUnion uiu = ``new` `UnsortedIntersectionUnion(); ` `        ``uiu.findPosition(a, b); ` `    ``} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:

```Intersection : 3,6,7,
Union : 1,2,3,5,6,7,8,20,```

See following post for sorted arrays.
Find Union and Intersection of two sorted arrays

Please write comments if you find any bug in above codes/algorithms, or find other ways to solve the same problem.

 `#  Python program to find union and intersection  ` `#  using sets ` `def` `printUnion(arr1,arr2,n1,n2): ` `    ``hs``=``set``() ` `    ``#  Inhsert the elements of arr1[] to set hs  ` `    ``for` `i ``in` `range``(``0``,n1): ` `        ``hs.add(arr1[i]) ` `    ``#  Inhsert the elements of arr1[] to set hs  ` `    ``for` `i ``in` `range``(``0``,n2): ` `        ``hs.add(arr2[i]) ` `    ``print``(``"Union:"``) ` `    ``for` `i ``in` `hs: ` `        ``print``(i,end``=``" "``) ` `    ``print``(``"\n"``) ` `    ``#  Prints intersection of arr1[0..n1-1] and  ` `    ``#  arr2[0..n2-1]  ` `def` `printIntersection(arr1,arr2,n1,n2): ` `    ``hs``=``set``() ` `    ``#  Insert the elements of arr1[] to set S  ` `    ``for` `i ``in` `range``(``0``,n1): ` `        ``hs.add(arr1[i]) ` `    ``print``(``"Intersection:"``) ` `    ``for` `i ``in` `range``(``0``,n2): ` `        ``#  If element is present in set then  ` `        ``#  push it to vector V ` `        ``if` `arr2[i] ``in` `hs: ` `            ``print``(arr2[i],end``=``" "``) ` `#  Driver Program  ` `arr1 ``=` `[ ``7``, ``1``, ``5``, ``2``, ``3``, ``6` `]  ` `arr2 ``=` `[ ``3``, ``8``, ``6``, ``20``, ``7` `]  ` `n1``=``len``(arr1) ` `n2``=``len``(arr2) ` `printUnion(arr1, arr2, n1, n2)  ` `printIntersection(arr1, arr2, n1, n2)  ` `         `  `# This artice is contributed by Kumar Suman . `

My Personal Notes arrow_drop_up