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: 0Input: 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)) |
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> |
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 |
4
Time Complexity: O(M*log(N))
Auxiliary Space: O(1)
Please Login to comment...