Open in App
Not now

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

• Difficulty Level : Medium
• 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 ` `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
Related Articles