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

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

4

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

4

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

4

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