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++ 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 |
3
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.
#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. |
2
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++ 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 |
Number of common elements: 3
Time Complexity: O(mlogm + nlogm)
Auxiliary Space: O(m)