 GeeksforGeeks App
Open App Browser
Continue

# 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 ``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

## 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 ``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

 ``

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 ``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)<

## 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)

My Personal Notes arrow_drop_up