Count number of common elements between two arrays
Last Updated :
14 Sep, 2024
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 1: 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 ith position of the resultant bitset is 1 then it implies that ith position of first and second bitsets are also 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;
}
/*package whatever //do not write package name here */
import java.util.*;
public class GFG {
static int bit1 = 0;
static int bit2 = 0;
static int bit3 = 0;
// Function to return the count of common elements
static 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 (index)position a[i]
bit1 = bit1 | (1 << a[i]);
}
// Traverse the second array
for (int i = 0; i < m; i++) {
// 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
int count = Integer.toBinaryString(bit3).split("1").length - 1;
return count;
}
// Driver code
public static void main(String[] args)
{
int[] a = { 1, 4, 7, 2, 3 };
int[] b = { 2, 11, 7, 4, 15, 20, 24 };
int n = a.length;
int m = b.length;
System.out.println(count_common(a, n, b, m));
}
}
// This code is contributed by aadityaburujwale.
# 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
// C# implementation of the approach
using System;
class GFG {
static int bit1 = 0;
static int bit2 = 0;
static int bit3 = 0;
// Function to return the count of common elements
static 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 (index)position a[i]
bit1 = bit1 | (1 << a[i]);
}
// Traverse the second array
for (int i = 0; i < m; i++) {
// 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
var count
= Convert.ToString(bit3, 2).Split("1").Length
- 1;
return count;
}
// Driver code
public static void Main(string[] args)
{
int[] a = { 1, 4, 7, 2, 3 };
int[] b = { 2, 11, 7, 4, 15, 20, 24 };
int n = a.Length;
int m = b.Length;
Console.WriteLine(count_common(a, n, b, m));
}
}
// This code is contributed by phasing17
// JavaScript implementation of the approach
const MAX = 100000;
let bit1 = 0;
let bit2 = 0;
let bit3 = 0;
// Function to return the count of common elements
function count_common(a, n, b, m)
{
// Traverse the first array
for (var i = 0; i < n; i++)
{
// Set 1 at (index)position a[i]
bit1 = bit1 | (1<<a[i]);
}
// Traverse the second array
for (var i = 0; i < m; i++)
{
// 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
var count = bit3.toString(2).split("1").length - 1;
return count;
}
// Driver code
var a = [ 1, 4, 7, 2, 3 ];
var b = [ 2, 11, 7, 4, 15, 20, 24 ];
var n = a.length;
var m = b.length;
console.log(count_common(a, n, b, m));
// This code is contributed by phasing17
Time Complexity: O(n + m)
Auxiliary Space: O(MAX)
Approach 2: We can also use hashmap to store frequencies of each element of both arrays a[] and b[] and sum up the minimum value for each element's frequency.
Follow given steps to solve the problem:
1. Traverse array a[] and store all frequencies in map freq1.
2. Traverse array b[] and store all frequencies in map freq2.
3. Traverse the map freq1 and sum up the minimum value between x.second and freq2[x.first] in result.
4. Return result as the final answer.
C++14
#include <bits/stdc++.h>
using namespace std;
int count_common(int *a, int& n, int *b, int& m)
{
unordered_map<int,int>freq1,freq2;
int result=0;
for(int i=0;i<n;i++)
freq1[a[i]]++;
for(int i=0;i<m;i++)
freq2[b[i]]++;
for(auto& x:freq1)
result+=min(x.second,freq2[x.first]);
return result;
}
// driver's code
int main()
{
int a[]={1,2,3};
int n=sizeof(a)/sizeof(a[0]);
int b[]={2,4,3};
int m=sizeof(b)/sizeof(b[0]);
cout<<count_common(a,n,b,m);
return 0;
}
// this code is contributed by prophet1999
import java.util.*;
public class GFG {
static int count_common(int[] a, int n, int[] b, int m)
{
HashMap<Integer, Integer> freq1 = new HashMap<>();
HashMap<Integer, Integer> freq2 = new HashMap<>();
int result = 0;
for (int i = 0; i < n; i++) {
if (!freq1.containsKey(a[i])) {
freq1.put(a[i], 1);
}
else {
freq1.put(a[i], freq1.get(a[i]) + 1);
}
}
for (int i = 0; i < m; i++) {
if (!freq2.containsKey(b[i])) {
freq2.put(b[i], 1);
}
else {
freq2.put(b[i], freq2.get(b[i]) + 1);
}
}
for (Map.Entry<Integer, Integer> x :
freq1.entrySet()) {
int p = x.getValue();
int q = 0;
if (freq2.containsKey(x.getKey())) {
q = freq2.get(x.getKey());
}
result += Math.min(p, q);
}
return result;
}
// driver's code
public static void main(String args[])
{
int[] a = { 1, 2, 3 };
int n = a.length;
int[] b = { 2, 4, 3 };
int m = b.length;
System.out.print(count_common(a, n, b, m));
}
}
// This code is contributed by Samim Hossain Mondal.
def count_common(a, n, b, m):
freq1 = {}
freq2 = {}
result = 0
for element in a:
if element in freq1:
freq1[element] += 1
else:
freq1[element] = 1
for element in b:
if element in freq2:
freq2[element] += 1
else:
freq2[element] = 1
for key, value in freq1.items():
if key in freq2:
result += min(value, freq2.get(key))
return result
# driver's code
a = [1, 2, 3]
n = len(a)
b = [2, 4, 3]
m = len(b)
print(count_common(a, n, b, m))
# This code is contributed by Samim Hossain Mondal.
using System;
using System.Collections.Generic;
class GFG {
static int count_common(int[] a, int n, int[] b, int m)
{
Dictionary<int, int> freq1
= new Dictionary<int, int>();
Dictionary<int, int> freq2
= new Dictionary<int, int>();
int result = 0;
for (int i = 0; i < n; i++) {
if (!freq1.ContainsKey(a[i])) {
freq1.Add(a[i], 1);
}
else {
freq1[a[i]]++;
}
}
for (int i = 0; i < m; i++) {
if (!freq2.ContainsKey(b[i])) {
freq2.Add(b[i], 1);
}
else {
freq2[b[i]]++;
}
}
foreach(KeyValuePair<int, int> x in freq1)
{
int p = x.Value;
int q = 0;
if (freq2.ContainsKey(x.Key)) {
q = freq2[x.Key];
}
result += Math.Min(p, q);
}
return result;
}
// driver's code
public static void Main()
{
int[] a = { 1, 2, 3 };
int n = a.Length;
int[] b = { 2, 4, 3 };
int m = b.Length;
Console.Write(count_common(a, n, b, m));
}
}
// This code is contributed by Samim Hossain Mondal.
function count_common(a, n, b, m)
{
let freq1 = new Map();
let freq2 = new Map();
let result = 0;
for(let i = 0; i < n; i++)
if(freq1.has(a[i]))
freq1.set(a[i], freq1.get(a[i])+1);
else
freq1.set(a[i], 1);
for(let i = 0; i < m; i++)
if(freq2.has(b[i]))
freq2.set(b[i], freq2.get(b[i])+1);
else
freq2.set(b[i], 1);
freq1.forEach((value, key) => {
if(freq2.has(key)){
result += Math.min(value, freq2.get(key));
}
else{
result += Math.min(value, 0);
}
});
return result;
}
// driver's code
let a = [1,2,3];
let n = a.length;
let b = [2,4,3];
let m = b.length;
console.log(count_common(a, n, b, m));
// this code is contributed by Samim Hossain Mondal.
Time Complexity: O(n+m)
Auxiliary Space: O(n+m)
Approach 3 : We can also use Binary search to check if the element of array a present in the array b or not.
1. Sort the array b in ascending order.
2. Initialize count as 0 , which we store the number of common elements from array a and array b.
3. Iterate each element in array a and use binary search to check if the element exists in array b.
4.If the element exists in array b, increase the count by 1.
5.Return the count .
Below is the implementation of the above approach :
C++
// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to check that element x is present in the array
bool binarysearch(int arr[], int m, int x)
{
int l = 0, r = m - 1;
while (l <= r) {
int mid = (l + r) / 2;
// Checking if the middle element is equal to x
if (arr[mid] == x) {
return true;
}
else if (arr[mid] < x) {
l = mid + 1;
}
else {
r = mid - 1;
}
}
// return true , if element x is present in the array
// else false
return false;
}
// Function to count common element
int count_common(int a[], int n, int b[], int m)
{
sort(b, b + m);
int count = 0;
// Iterate each element of array a
for (int i = 0; i < n; i++) {
// Checking if the element of array a is present in
// array b using the binary search function
if (binarysearch(b, m, a[i])) {
count++;
}
}
// Return count of common element
return count;
}
// Drive Code
int main()
{
int a[] = { 1, 4, 7, 2, 3 };
int n = sizeof(a) / sizeof(a[0]);
int b[] = { 2, 11, 7, 4, 15, 20, 24 };
int m = sizeof(b) / sizeof(b[0]);
// Function call
cout << "Number of common elements: "
<< count_common(a, n, b, m) << "\n";
return 0;
}
// This code is contributed by nikhilsainiofficial546
import java.util.Arrays;
class GFG
{
// Function to check that element x is present in the
// array
public static boolean binarysearch(int arr[], int m,
int x)
{
int l = 0;
int r = m - 1;
while (l <= r) {
int mid = (l + r) / 2;
// Checking if the middle element is equal to x
if (arr[mid] == x) {
return true;
}
else if (arr[mid] < x) {
l = mid + 1;
}
else {
r = mid - 1;
}
}
// return true , if element x is present in the
// array else false
return false;
}
// Function to count common element
public static int count_common(int a[], int n, int b[],
int m)
{
Arrays.sort(b);
int count = 0;
// Iterate each element of array a
for (int i = 0; i < n; i++) {
// Checking if the element of array a is
// present in array b using the binary search
// function
if (binarysearch(b, m, a[i])) {
count++;
}
}
// Return count of common element
return count;
}
// Drive Code
public static void main(String[] args)
{
int a[] = { 1, 4, 7, 2, 3 };
int n = a.length;
int b[] = { 2, 11, 7, 4, 15, 20, 24 };
int m = b.length;
// Function call
System.out.println("Number of common elements: "
+ count_common(a, n, b, m));
}
}
// This code is contributed by phasing17.
# python3 implementation of the above approach
# Function to check that element x is present in the array
def binarysearch(arr, m, x):
l, r = 0, m - 1
while l <= r:
mid = (l + r) // 2
# Checking if the middle element is equal to x
if arr[mid] == x:
return True
elif arr[mid] < x:
l = mid + 1
else:
r = mid - 1
# return true , if element x is present in the array
# else false
return False
# Function to count common element
def count_common(a, n, b, m):
b.sort()
count = 0
# Iterate each element of array a
for i in range(n):
# Checking if the element of array a is present in
# array b using the binary search function
if binarysearch(b, m, a[i]):
count += 1
# Return count of common element
return count
# Drive Code
a = [1, 4, 7, 2, 3]
n = len(a)
b = [2, 11, 7, 4, 15, 20, 24]
m = len(b)
# Function call
print("Number of common elements:", count_common(a, n, b, m))
# This code is contributed by nikhilsainiofficial546
// C# program to count common elements in two arrays
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
class GFG {
static void Main(string[] args)
{
int[] a = new int[] { 1, 4, 7, 2, 3 };
int n = a.Length;
int[] b = new int[] { 2, 11, 7, 4, 15, 20, 24 };
int m = b.Length;
// Function call
Console.WriteLine("Number of common elements: "
+ count_common(a, n, b, m));
Console.ReadLine();
}
// Function to count common element
public static int count_common(int[] a, int n, int[] b,
int m)
{
Array.Sort(b);
int count = 0;
// Iterate each element of array a
for (int i = 0; i < n; i++) {
// Checking if the element of array a is
// present in array b using the binary search
// function
if (binarysearch(b, m, a[i])) {
count++;
}
}
// Return count of common element
return count;
}
// Function to check that element x is present in the
// array
public static bool binarysearch(int[] arr, int m, int x)
{
int l = 0;
int r = m - 1;
while (l <= r) {
int mid = (l + r) / 2;
// Checking if the middle element is equal to x
if (arr[mid] == x) {
return true;
}
else if (arr[mid] < x) {
l = mid + 1;
}
else {
r = mid - 1;
}
}
// return true , if element x is present in the
// array else false
return false;
}
}
// This code is contributed by phasing17.
// JavaScript implementation of the above approach
// Function to check that element x is present in the array
function binarysearch(arr, m, x) {
let l = 0;
let r = m - 1;
while (l <= r) {
let mid = Math.floor((l + r) / 2);
// Checking if the middle element is equal to x
if (arr[mid] === x) {
return true;
} else if (arr[mid] < x) {
l = mid + 1;
} else {
r = mid - 1;
}
}
// return true , if element x is present in the array
// else false
return false;
}
// Function to count common element
function count_common(a, n, b, m) {
a.sort(function(x, y)
{
return x - y;
});
b.sort(function(x, y)
{
return x - y;
});
let count = 0;
// Iterate each element of array a
for (let i = 0; i < n; i++) {
// Checking if the element of array a is present in
// array b using the binary search function
if (binarysearch(b, m, a[i])) {
count++;
}
}
// Return count of common element
return count;
}
// Drive Code
let a = [1, 4, 7, 2, 3];
let n = a.length;
let b = [2, 11, 7, 4, 15, 20, 24];
let m = b.length;
// Function call
console.log("Number of common elements:", count_common(a, n, b, m));
// This code is contributed by phasing17
OutputNumber of common elements: 3
Time Complexity: O(mlogm + nlogm)
Auxiliary Space: O(m)
Similar Reads
DSA Tutorial - Learn Data Structures and Algorithms DSA (Data Structures and Algorithms) is the study of organizing data efficiently using data structures like arrays, stacks, and trees, paired with step-by-step procedures (or algorithms) to solve problems effectively. Data structures manage how data is stored and accessed, while algorithms focus on
7 min read
Quick Sort QuickSort is a sorting algorithm based on the Divide and Conquer that picks an element as a pivot and partitions the given array around the picked pivot by placing the pivot in its correct position in the sorted array. It works on the principle of divide and conquer, breaking down the problem into s
12 min read
Merge Sort - Data Structure and Algorithms Tutorials Merge sort is a popular sorting algorithm known for its efficiency and stability. It follows the divide-and-conquer approach. It works by recursively dividing the input array into two halves, recursively sorting the two halves and finally merging them back together to obtain the sorted array. Merge
14 min read
Data Structures Tutorial Data structures are the fundamental building blocks of computer programming. They define how data is organized, stored, and manipulated within a program. Understanding data structures is very important for developing efficient and effective algorithms. What is Data Structure?A data structure is a st
2 min read
Bubble Sort Algorithm Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in the wrong order. This algorithm is not suitable for large data sets as its average and worst-case time complexity are quite high.We sort the array using multiple passes. After the fir
8 min read
Breadth First Search or BFS for a Graph Given a undirected graph represented by an adjacency list adj, where each adj[i] represents the list of vertices connected to vertex i. Perform a Breadth First Search (BFS) traversal starting from vertex 0, visiting vertices from left to right according to the adjacency list, and return a list conta
15+ min read
Binary Search Algorithm - Iterative and Recursive Implementation Binary Search Algorithm is a searching algorithm used in a sorted array by repeatedly dividing the search interval in half. The idea of binary search is to use the information that the array is sorted and reduce the time complexity to O(log N). Binary Search AlgorithmConditions to apply Binary Searc
15 min read
Insertion Sort Algorithm Insertion sort is a simple sorting algorithm that works by iteratively inserting each element of an unsorted list into its correct position in a sorted portion of the list. It is like sorting playing cards in your hands. You split the cards into two groups: the sorted cards and the unsorted cards. T
9 min read
Array Data Structure Guide In this article, we introduce array, implementation in different popular languages, its basic operations and commonly seen problems / interview questions. An array stores items (in case of C/C++ and Java Primitive Arrays) or their references (in case of Python, JS, Java Non-Primitive) at contiguous
4 min read
Sorting Algorithms A Sorting Algorithm is used to rearrange a given array or list of elements in an order. For example, a given array [10, 20, 5, 2] becomes [2, 5, 10, 20] after sorting in increasing order and becomes [20, 10, 5, 2] after sorting in decreasing order. There exist different sorting algorithms for differ
3 min read