Count number of common elements between a sorted array and a reverse sorted array

Last Updated : 22 Mar, 2023

Given two arrays consisting of N distinct integers such that the array A[] and B[] are sorted in ascending and descending order respectively, the task is to find the number of values common in both arrays.

Examples:

Input: A[] = {1, 10, 100}, B[] = {200, 20, 2}
Output: 0

Input: A[] = {2, 4, 5, 8, 12, 13, 17, 18, 20, 22, 309, 999}, B[] = {109, 99, 68, 54, 22, 19, 17, 13, 11, 5, 3, 1}
Output: 4

Naive Approach:- Check for all elements in array A that is present in array B or not if Yes increase the count of pair.

Implementation:-

C++

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to count the number of
// elements common in both the arrays
int countEqual(int A[], int B[], int N)
{
      //variable to store answer
      int ans=0;
       
      //first loop for array A
      for(int i=0;i<N;i++)
    {
          //This loop to find array A element in B
          for(int j=0;j<N;j++)
        {
              //if found then increase count and exit the loop
              if(A[i]==B[j])
            {
                  ans++;
                  break;
            }
        }
    }
      return ans;
}
 
// Driver Code
int main()
{
    int A[] = { 2, 4, 5, 8, 12, 13, 17,
                18, 20, 22, 309, 999 };
    int B[] = { 109, 99, 68, 54, 22, 19,
                17, 13, 11, 5, 3, 1 };
    int N = sizeof(A) / sizeof(int);
    cout << countEqual(A, B, N);
 
    return 0;
}
//This code contributed by shubhamrajput6156

Java

import java.io.*;
 
class GFG 
{
 
  // Java program for the above approach
 
  // Function to count the number of
  // elements common in both the arrays
  public static int countEqual(int[] A, int[] B, int N)
  {
    // variable to store answer
    int ans = 0;
 
    // first loop for array A
    for (int i = 0;i < N;i++)
    {
      // This loop to find array A element in B
      for (int j = 0;j < N;j++)
      {
 
        // if found then increase count and exit the loop
        if (A[i] == B[j])
        {
          ans++;
          break;
        }
      }
    }
    return ans;
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    int[] A = {2, 4, 5, 8, 12, 13, 17, 18, 20, 22, 309, 999};
    int[] B = {109, 99, 68, 54, 22, 19, 17, 13, 11, 5, 3, 1};
 
 
    int N = A.length;
    System.out.print(countEqual(A, B, N));
 
  }
} 
 
// This code contributed by bhardwajji

Javascript

// JS code to implement the approach
 
// JavaScript code for the above approach
function countEqual(A, B, N)
{
    // variable to store answer
    let ans = 0;
 
    // first loop for array A
    for (let i = 0; i < N; i++)
    {
     
        // This loop to find array A element in B
        for (let j = 0; j < N; j++)
        {
         
            // if found then increase count and exit the
            // loop
            if (A[i] == B[j]) {
                ans++;
                break;
            }
        }
    }
    return ans;
}
 
// Driver Code
let A = [ 2, 4, 5, 8, 12, 13, 17, 18, 20, 22, 309, 999 ];
let B = [ 109, 99, 68, 54, 22, 19, 17, 13, 11, 5, 3, 1 ];
let N = A.length;
console.log(countEqual(A, B, N));
 
// This code is contributed by phasing17

C#

// C# program for the above approach
using System;
 
class GFG
{
 
// Function to count the number of
// elements common in both the arrays
public static int countEqual(int[] A, int[] B, int N)
{
    // variable to store answer
    int ans = 0;
 
    // first loop for array A
    for (int i = 0;i < N;i++)
    {
    // This loop to find array A element in B
    for (int j = 0;j < N;j++)
    {
 
        // if found then increase count and exit the loop
        if (A[i] == B[j])
        {
        ans++;
        break;
        }
    }
    }
    return ans;
}
 
// Driver Code
public static void Main()
{
    int[] A = {2, 4, 5, 8, 12, 13, 17, 18, 20, 22, 309, 999};
    int[] B = {109, 99, 68, 54, 22, 19, 17, 13, 11, 5, 3, 1};
 
 
    int N = A.Length;
    Console.WriteLine(countEqual(A, B, N));
 
}
}
 
// This code is contributed by Pushpesh Raj.

Python3

# python program for the above approach
 
# Function to count the number of
# elements common in both the arrays
def countEqual(A, B, N):
   
      # variable to store answer
    ans = 0
     
    # first loop for array A
    for i in range(N):
       
          # This loop to find array A element in B
        for j in range(N):
           
              # if found then increase count and exit the loop
            if A[i] == B[j]:
                ans += 1
                break
    return ans
 
# driver code
A = [2, 4, 5, 8, 12, 13, 17, 18, 20, 22, 309, 999]
B = [109, 99, 68, 54, 22, 19, 17, 13, 11, 5, 3, 1]
N = len(A)
print(countEqual(A, B, N))

Output

Time Complexity:- O(N^2)
Auxiliary Space:- O(1)

Approach: The given problem can be solved by using the Two Pointer Approach. Follow the steps below to solve the problem:

Initialize two variables, say first as 0 and second as (N – 1) that is used to traverse the array A[] and B[] from the front and back respectively.
Initialize a variable, say count as 0 that stores the count of numbers common in the array A[] and B[].
Iterate a loop until first < N and second >= 0 and perform the following steps:
- If the value of A[first] is equal to B[second], then increment the values of count and first and decrement the value of the second.
- If the value of A[first] is less than B[second], then increment the value of first.
- If the value of A[first] is greater than B[second], then decrement the value of the second.
After completing the above steps, print the value of count as the result.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to count the number of
// elements common in both the arrays
int countEqual(int A[], int B[], int N)
{
    // Used to traverse array A[] and
    // B[] from the front and the back
    int first = 0;
    int second = N - 1;
 
    // Stores the count of numbers
    // common in both array
    int count = 0;
 
    while (first < N && second >= 0) {
 
        // If A[first] is less than
        // B[second]
        if (A[first] < B[second]) {
 
            // Increment the value
            // of first
            first++;
        }
 
        // IF B[second] is less
        // than A[first]
        else if (B[second] < A[first]) {
 
            // Decrement the value
            // of second
            second--;
        }
 
        // A[first] is equal to
        // B[second]
        else {
 
            // Increment the value
            // of count
            count++;
 
            // Increment the value
            // of first
            first++;
 
            // Decrement the value
            // of second
            second--;
        }
    }
 
    // Return the value of count
    return count;
}
 
// Driver Code
int main()
{
    int A[] = { 2, 4, 5, 8, 12, 13, 17,
                18, 20, 22, 309, 999 };
    int B[] = { 109, 99, 68, 54, 22, 19,
                17, 13, 11, 5, 3, 1 };
    int N = sizeof(A) / sizeof(int);
    cout << countEqual(A, B, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG
{
 
// Function to count the number of
// elements common in both the arrays
static int countEqual(int A[], int B[], int N)
{
   
    // Used to traverse array A[] and
    // B[] from the front and the back
    int first = 0;
    int second = N - 1;
   
    // Stores the count of numbers
    // common in both array
    int count = 0;
   
    while (first < N && second >= 0) {
   
        // If A[first] is less than
        // B[second]
        if (A[first] < B[second]) {
   
            // Increment the value
            // of first
            first++;
        }
   
        // IF B[second] is less
        // than A[first]
        else if (B[second] < A[first]) {
   
            // Decrement the value
            // of second
            second--;
        }
   
        // A[first] is equal to
        // B[second]
        else {
   
            // Increment the value
            // of count
            count++;
   
            // Increment the value
            // of first
            first++;
   
            // Decrement the value
            // of second
            second--;
        }
    }
   
    // Return the value of count
    return count;
}
   
    // Driver Code
    public static void main(String[] args)
    {
 
        int A[] = { 2, 4, 5, 8, 12, 13, 17,
                18, 20, 22, 309, 999 };
    int B[] = { 109, 99, 68, 54, 22, 19,
                17, 13, 11, 5, 3, 1 };
    int N = A.length;
    System.out.println(countEqual(A, B, N));
    }
}
 
// This code is contributed by susmitakundugoaldanga.

Python3

# Python program for the above approach
 
# Function to count the number of
# elements common in both the arrays
def countEqual(A, B, N) :
     
    # Used to traverse array A[] and
    # B[] from the front and the back
    first = 0
    second = N - 1
  
    # Stores the count of numbers
    # common in both array
    count = 0
  
    while (first < N and second >= 0) :
  
        # If A[first] is less than
        # B[second]
        if (A[first] < B[second]) :
  
            # Increment the value
            # of first
            first += 1
         
  
        # IF B[second] is less
        # than A[first]
        elif (B[second] < A[first]) :
  
            # Decrement the value
            # of second
            second -= 1
         
  
        # A[first] is equal to
        # B[second]
        else :
  
            # Increment the value
            # of count
            count += 1
  
            # Increment the value
            # of first
            first += 1
  
            # Decrement the value
            # of second
            second -= 1
         
    # Return the value of count
    return count
 
# Driver Code
 
A= [ 2, 4, 5, 8, 12, 13, 17,
                18, 20, 22, 309, 999 ]
B = [ 109, 99, 68, 54, 22, 19,
                17, 13, 11, 5, 3, 1 ]
N = len(A)
print(countEqual(A, B, N))
 
# This code is contributed by sanjou_62.

C#

// C# program for the above approach
using System;
 
class GFG{
     
// Function to count the number of
// elements common in both the arrays
static int countEqual(int[] A, int[] B, int N)
{
 
    // Used to traverse array A[] and
    // B[] from the front and the back
    int first = 0;
    int second = N - 1;
 
    // Stores the count of numbers
    // common in both array
    int count = 0;
 
    while (first < N && second >= 0) 
    {
         
        // If A[first] is less than
        // B[second]
        if (A[first] < B[second]) 
        {
             
            // Increment the value
            // of first
            first++;
        }
 
        // IF B[second] is less
        // than A[first]
        else if (B[second] < A[first]) 
        {
 
            // Decrement the value
            // of second
            second--;
        }
 
        // A[first] is equal to
        // B[second]
        else
        {
 
            // Increment the value
            // of count
            count++;
 
            // Increment the value
            // of first
            first++;
 
            // Decrement the value
            // of second
            second--;
        }
    }
 
    // Return the value of count
    return count;
}
 
// Driver code
static void Main()
{
    int[] A = { 2, 4, 5, 8, 12, 13,
                17, 18, 20, 22, 309, 999 };
    int[] B = { 109, 99, 68, 54, 22, 19,
                17, 13, 11, 5, 3, 1 };
    int N = A.Length;
     
    Console.WriteLine(countEqual(A, B, N));
}
}
 
// This code is contributed by abhinavjain194

Javascript

<script>
// Javascript program for the above approach
 
// Function to count the number of
// elements common in both the arrays
function countEqual(A, B, N)
{
 
    // Used to traverse array A[] and
    // B[] from the front and the back
    let first = 0;
    let second = N - 1;
 
    // Stores the count of numbers
    // common in both array
    let count = 0;
 
    while (first < N && second >= 0) {
 
        // If A[first] is less than
        // B[second]
        if (A[first] < B[second]) {
 
            // Increment the value
            // of first
            first++;
        }
 
        // IF B[second] is less
        // than A[first]
        else if (B[second] < A[first]) {
 
            // Decrement the value
            // of second
            second--;
        }
 
        // A[first] is equal to
        // B[second]
        else {
 
            // Increment the value
            // of count
            count++;
 
            // Increment the value
            // of first
            first++;
 
            // Decrement the value
            // of second
            second--;
        }
    }
 
    // Return the value of count
    return count;
}
 
// Driver Code
 
let A = [2, 4, 5, 8, 12, 13, 17,
    18, 20, 22, 309, 999];
let B = [109, 99, 68, 54, 22, 19,
    17, 13, 11, 5, 3, 1];
let N = A.length;
document.write(countEqual(A, B, N));
 
// This code is contributed _saurabh_jaiswal
</script>

Output

Time Complexity: O(N)
Auxiliary Space: O(1)

Another Approach : We will use Binary search to check if the element of array B[] is present in the array A[] or not because array A[] is already sorted in increasing order. So , we can use binary search for finding elements.

Below is the implementation of the above approach :

C++

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
//Function to check if x is present in the array or not
bool binarysearch(int arr[], int N, int x)
{ 
    int l = 0, r = N - 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 the number of
// elements common in both the arrays
int countEqual(int A[], int B[], int N, int M)
{  int count = 0;
 
    // Iterate each element of array B
    for (int i = 0; i < M; i++) 
    {
        // Checking  if the element of array B is present in
        // array A using the binary search
        if (binarysearch(A, N, B[i]))
        {
            count++;
        }
    }
    // Return count of common element
    return count;
}
 
// Driver Code
int main()
{
    int A[] = { 2, 4, 5, 8, 12, 13, 17,
               18, 20, 22, 309, 999 };
    int B[] = { 109, 99, 68, 54, 22
                , 19,17, 13, 11, 5, 3, 1 };
     
    int N = sizeof(A) / sizeof(int);
    int M = sizeof(B) / sizeof(int);
   
    //Function call
    cout << countEqual(A, B, N, M)<<endl;
 
    return 0;
}
 
// This code is contributed by nikhilsainiofficial546

Java

// Java program for the above approach
import java.util.Arrays;
 
class Main {
     
    // Function to check if x is present in the array or not
    static boolean binarySearch(int[] arr, int N, int x) {
        int l = 0, r = N - 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 the number of elements common in both the arrays
    static int countEqual(int[] A, int[] B, int N, int M) {
        int count = 0;
        // Sort array A
        Arrays.sort(A);
        // Iterate each element of array B
        for (int i = 0; i < M; i++) {
            // Checking  if the element of array B is present in array A using the binary search
            if (binarySearch(A, N, B[i])) {
                count++;
            }
        }
        // Return count of common element
        return count;
    }
     
    // Driver Code
    public static void main(String[] args) {
        int[] A = { 2, 4, 5, 8, 12, 13, 17, 18, 20, 22, 309, 999 };
        int[] B = { 109, 99, 68, 54, 22, 19, 17, 13, 11, 5, 3, 1 };
         
        int N = A.length;
        int M = B.length;
       
        //Function call
        System.out.println(countEqual(A, B, N, M));
    }
}

Python3

#Python program for the above approach 
# Function to check if x is present in the array or not
def binarySearch(arr, N, x):
    l = 0
    r = N - 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 the number of elements common in both the arrays
def countEqual(A, B, N, M):
    count = 0
    # Sort array A
    A.sort() 
    # Iterate each element of array B
    for i in range(M): 
        # Checking  if the element of array B is present in array A using the binary search
        if binarySearch(A, N, B[i]): 
            count += 1
    # Return count of common element
    return count
 
# Driver Code
A = [ 2, 4, 5, 8, 12, 13, 17, 18, 20, 22, 309, 999 ]
B = [ 109, 99, 68, 54, 22, 19, 17, 13, 11, 5, 3, 1 ]
      
N = len(A)
M = len(B)
       
#Function call
print(countEqual(A, B, N, M))

C#

// C# program for the above approach
using System;
 
class Program
{
   
  // Function to check if x is present in the array or not
  static bool BinarySearch(int[] arr, int N, int x)
  {
    int l = 0, r = N - 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 the number of
  // elements common in both the arrays
  static int CountEqual(int[] A, int[] B, int N, int M)
  {
    int count = 0;
 
    // Iterate each element of array B
    for (int i = 0; i < M; i++) {
      // Checking if the element of array B is present
      // in array A using the binary search
      if (BinarySearch(A, N, B[i])) {
        count++;
      }
    }
    // Return count of common element
    return count;
  }
 
  // Driver Code
  static void Main()
  {
    int[] A = { 2,  4,  5,  8,  12,  13,
               17, 18, 20, 22, 309, 999 };
    int[] B = { 109, 99, 68, 54, 22, 19,
               17,  13, 11, 5,  3,  1 };
 
    int N = A.Length;
    int M = B.Length;
 
    // Function call
    Console.WriteLine(CountEqual(A, B, N, M));
 
    Console.ReadLine();
  }
}

Javascript

// JavaScript program to implement the approach
 
// Function to check if x is present in the array or not
function binarysearch(arr, N, x) { 
  let l = 0, r = N - 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 the number of
// elements common in both the arrays
function countEqual(A, B, N, M) {  
  let count = 0;
 
  // Iterate each element of array B
  for (let i = 0; i < M; i++) {
    // Checking  if the element of array B is present in
    // array A using the binary search
    if (binarysearch(A, N, B[i])) {
      count++;
    }
  }
  // Return count of common element
  return count;
}
 
// Driver Code
(() => {
  const A = [2, 4, 5, 8, 12, 13, 17, 18, 20, 22, 309, 999];
  const B = [109, 99, 68, 54, 22, 19, 17, 13, 11, 5, 3, 1];
 
  const N = A.length;
  const M = B.length;
 
  // Function call
  console.log(countEqual(A, B, N, M));
})();
 
// This code is contributed by phasing17

Output

Time Complexity: O(M*log(N))
Auxiliary Space: O(1)

Suggest improvement

Count number of common elements between two arrays

Share your thoughts in the comments

Count number of common elements between a sorted array and a reverse sorted array

C++

Java

Javascript

C#

Python3

C++

Java

Python3

C#

Javascript

C++

Java

Python3

C#

Javascript

Please Login to comment...

Similar Reads

What kind of Experience do you want to share?