Skip to content

Complete Interview Preparation at 20% off | Use code: PREPAREKARO Check Now

Related Articles

Related Articles

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

View Discussion
Improve Article
Save Article
Like Article
  • Last Updated : 26 May, 2021

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 the 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

 

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: 
4
 
Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes
arrow_drop_up
Previous
Count triplets from a sorted array having difference between adjacent elements equal to D
Next

Adobe Interview Experience for Computer Scientist-1
Recommended Articles
Page :
Count of unique pairs (i, j) in an array such that sum of A[i] and reverse of A[j] is equal to sum of reverse of A[i] and A[j]
12, Feb 21
Number of triangles formed by joining vertices of n-sided polygon with two common sides and no common sides
19, Jun 19
Count number of common elements between two arrays by using Bitset and Bitwise operation
19, Jun 19
Find common elements in three sorted arrays
18, Sep 14
Count common elements in two arrays containing multiples of N and M
12, Jun 19
Sort an array where a subarray of a sorted array is in reverse order
24, Jul 18
Absolute difference between the count of set bits in N and its reverse
30, Mar 21
Count common elements in two arrays which are in Arithmetic Progression
07, May 20
Remove minimum number of elements such that no common element exist in both array
23, Sep 17
Count triplets from a sorted array having difference between adjacent elements equal to D
12, May 21
Count number of elements between two given elements in array
16, Oct 17
Number of common tangents between two circles if their centers and radius is given
15, May 19
Search an element in a reverse sorted array
24, Sep 20
Find the index having sum of elements on its left equal to reverse of the sum of elements on its right
13, Jan 21
Count of Array elements greater than all elements on its left and at least K elements on its right
29, Jul 20
Count of Array elements greater than all elements on its left and next K elements on its right
05, Aug 20
C++ Program to Count of Array elements greater than all elements on its left and at least K elements on its right
21, Jan 22
Java Program to Count of Array elements greater than all elements on its left and at least K elements on its right
21, Jan 22
Count of binary strings of length N having equal count of 0's and 1's and count of 1's ≥ count of 0's in each prefix substring
25, Jul 20
Reverse and Add given number repeatedly to get a Palindrome number
30, Aug 16
Generate all possible sorted arrays from alternate elements of two given sorted arrays
01, Jul 15
Circularly Sorted Array (Sorted and Rotated Array)
01, Jun 22
Sort an array having first N elements sorted and last M elements are unsorted
15, Jun 21
Find common elements of Stack and Queue
20, Apr 22
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
nichil942singh
@nichil942singh
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!