# Count number of common elements between two arrays by using Bitset and Bitwise operation

Given two arrays **a[]** and **b[]**, the task is to find the count of common elements in both the given arrays. **Note** that both the arrays contain distinct (individually) positive integers.

**Examples:**

Input:a[] = {1, 2, 3}, b[] = {2, 4, 3}

Output:2

2 and 3 are common to both the arrays.

Input:a[] = {1, 4, 7, 2, 3}, b[] = {2, 11, 7, 4, 15, 20, 24}

Output:3

**Approach:** We will use 3 bitset of same size. First we will traverse first array and set the bit 1 to position **a[i]** in first bitset.

After that we will traverse second array and set the bit 1 to position **b[i]** in second bitset.

At last we will find the bitwise AND of both the bitsets and if the **i ^{th}** position of the resultant bitset is

**1**then it implies that

**i**position of first and second bitsets are also

^{th}**1**and

**i**is the common element in both the arrays.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` `#define MAX 100000 ` `bitset<MAX> bit1, bit2, bit3; ` ` ` `// Function to return the count of common elements ` `int` `count_common(` `int` `a[], ` `int` `n, ` `int` `b[], ` `int` `m) ` `{ ` ` ` ` ` `// Traverse the first array ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` ` ` `// Set 1 at position a[i] ` ` ` `bit1.set(a[i]); ` ` ` `} ` ` ` ` ` `// Traverse the second array ` ` ` `for` `(` `int` `i = 0; i < m; i++) { ` ` ` ` ` `// Set 1 at position b[i] ` ` ` `bit2.set(b[i]); ` ` ` `} ` ` ` ` ` `// Bitwise AND of both the bitsets ` ` ` `bit3 = bit1 & bit2; ` ` ` ` ` `// Find the count of 1's ` ` ` `int` `count = bit3.count(); ` ` ` ` ` `return` `count; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` ` ` `int` `a[] = { 1, 4, 7, 2, 3 }; ` ` ` `int` `b[] = { 2, 11, 7, 4, 15, 20, 24 }; ` ` ` `int` `n = ` `sizeof` `(a) / ` `sizeof` `(a[0]); ` ` ` `int` `m = ` `sizeof` `(b) / ` `sizeof` `(b[0]); ` ` ` ` ` `cout << count_common(a, n, b, m); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation of the approach ` ` ` `MAX` `=` `100000` `bit1 , bit2, bit3 ` `=` `0` `, ` `0` `, ` `0` ` ` `# Function to return the count of common elements ` `def` `count_common(a, n, b, m) : ` ` ` ` ` `# Traverse the first array ` ` ` `for` `i ` `in` `range` `(n) : ` ` ` ` ` `global` `bit1, bit2, bit3 ` ` ` ` ` `# Set 1 at (index)position a[i] ` ` ` `bit1 ` `=` `bit1 | (` `1` `<<a[i]) ` ` ` ` ` `# Traverse the second array ` ` ` `for` `i ` `in` `range` `(m) : ` ` ` ` ` `# Set 1 at (index)position b[i] ` ` ` `bit2 ` `=` `bit2 | (` `1` `<<b[i]) ` ` ` ` ` `# Bitwise AND of both the bitsets ` ` ` `bit3 ` `=` `bit1 & bit2; ` ` ` ` ` `# Find the count of 1's ` ` ` `count ` `=` `bin` `(bit3).count(` `'1'` `); ` ` ` ` ` `return` `count; ` ` ` `# Driver code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` ` ` `a ` `=` `[ ` `1` `, ` `4` `, ` `7` `, ` `2` `, ` `3` `]; ` ` ` `b ` `=` `[ ` `2` `, ` `11` `, ` `7` `, ` `4` `, ` `15` `, ` `20` `, ` `24` `]; ` ` ` `n ` `=` `len` `(a); ` ` ` `m ` `=` `len` `(b); ` ` ` ` ` `print` `(count_common(a, n, b, m)); ` ` ` `# This code is contributed by AnkitRai01 ` |

*chevron_right*

*filter_none*

**Output:**

3

## Recommended Posts:

- Count pairs from two arrays whose modulo operation yields K
- Count number of trailing zeros in Binary representation of a number using Bitset
- Count number of set bits in a range using bitset
- Find common elements in three sorted arrays
- intersection_update() in Python to find common elements in n arrays
- Count pairs with Bitwise-AND as even number
- Count pairs with Bitwise XOR as EVEN number
- Count pairs with Bitwise XOR as ODD number
- Count pairs with Bitwise OR as Even number
- Count pairs with Bitwise AND as ODD number
- Count the number of sub-arrays such that the average of elements present in the sub-array is greater than that not present in the sub-array
- Count sub-arrays which have elements less than or equal to X
- Count of arrays in which all adjacent elements are such that one of them divide the another
- Count arrays of length K whose product of elements is same as that of given array
- Count of sub-arrays whose elements can be re-arranged to form palindromes

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.