Related Articles

# Count pairs from two arrays with difference exceeding K

• Last Updated : 23 Jun, 2021

Given two integer arrays arr[] and brr[] consisting of distinct elements of size N and M respectively and an integer K, the task is to find the count of pairs(arr[i], brr[j]) such that (brr[j] – arr[i]) > K.

Examples:

Input: arr[] = {5, 9, 1, 8}, brr[] {10, 12, 7, 4, 2, 3}, K = 3
Output:
Explanation:
Possible pairs that satisfy the given conditions are: { (5, 10), (5, 12), (1, 10), (1, 12), (1, 7), (8, 12) }.
Therefore, the required output is 6.

Input: arr[] = {2, 10}, brr[] = {5, 7}, K = 2
Output:
Explanation:
Possible pairs that satisfy the given conditions are: { (2, 5), (2, 7) }.
Therefore, the required output is 2.

Naive approach: The simplest approach to solve this problem is to traverse the array and generate all possible pairs of the given array and for each pair, check if (brr[j] – arr[i]) > K or not. If found to be true then increment the counter. Finally, print the value of the counter.

Time Complexity: O(N × M)
Auxiliary Space: O(1)

Efficient approach: To optimize the above approach the idea is to first sort the array and then use two pointer techniques. Follow the steps below to solve the problem:

• Initialize a variable, say cntPairs to store the count of pairs that satisfy the given conditions.
• Sort the given array.
• Initialize two variables, say i = 0 and j = 0 to store the index of left and right pointers respectively.
• Traverse both the array and check if (brr[j] – arr[i]) > K or not. If found to be true then update the value of cntPairs += (M – j) and increment the value of i pointer variable.
• Otherwise, increment the value of j pointer variable.
• Finally, print the value of cntPrint.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach``#include ``using` `namespace` `std;` `// Function to count pairs that satisfy``// the given conditions``int` `count_pairs(``int` `arr[], ``int` `brr[],``                ``int` `N, ``int` `M, ``int` `K)``{``    ``// Stores index of``    ``// the left pointer.``    ``int` `i = 0;` `    ``// Stores index of``    ``// the right pointer``    ``int` `j = 0;` `    ``// Stores count of total pairs``    ``// that satisfy the conditions``    ``int` `cntPairs = 0;` `    ``// Sort arr[] array``    ``sort(arr, arr + N);` `    ``// Sort brr[] array``    ``sort(brr, brr + M);` `    ``// Traverse both the array``    ``// and count then pairs``    ``while` `(i < N && j < M) {` `        ``// If the value of``        ``// (brr[j] - arr[i]) exceeds K``        ``if` `(brr[j] - arr[i] > K) {` `            ``// Update cntPairs``            ``cntPairs += (M - j);` `            ``// Update``            ``i++;``        ``}``        ``else` `{` `            ``// Update j``            ``j++;``        ``}``    ``}` `    ``return` `cntPairs;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 5, 9, 1, 8 };``    ``int` `brr[] = { 10, 12, 7, 4, 2, 3 };``    ``int` `K = 3;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `M = ``sizeof``(brr) / ``sizeof``(brr);``    ``cout << count_pairs(arr, brr, N, M, K);``    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;` `class` `GFG{``  ` `// Function to count pairs that satisfy``// the given conditions``static` `int` `count_pairs(``int` `arr[], ``int` `brr[],``                       ``int` `N, ``int` `M, ``int` `K)``{``    ` `    ``// Stores index of``    ``// the left pointer.``    ``int` `i = ``0``;` `    ``// Stores index of``    ``// the right pointer``    ``int` `j = ``0``;` `    ``// Stores count of total pairs``    ``// that satisfy the conditions``    ``int` `cntPairs = ``0``;` `    ``// Sort arr[] array``    ``Arrays.sort(arr);` `    ``// Sort brr[] array``    ``Arrays.sort(brr);` `    ``// Traverse both the array``    ``// and count then pairs``    ``while` `(i < N && j < M)``    ``{``        ` `        ``// If the value of``        ``// (brr[j] - arr[i]) exceeds K``        ``if` `(brr[j] - arr[i] > K)``        ``{``            ` `            ``// Update cntPairs``            ``cntPairs += (M - j);``            ` `            ``// Update``            ``i++;``        ``}``        ``else``        ``{``            ` `            ``// Update j``            ``j++;``        ``}``    ``}``    ``return` `cntPairs;``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``int` `arr[] = { ``5``, ``9``, ``1``, ``8` `};``    ``int` `brr[] = { ``10``, ``12``, ``7``, ``4``, ``2``, ``3` `};``    ``int` `K = ``3``;``    ` `    ``int` `N = arr.length;``    ``int` `M = brr.length;``    ` `    ``System.out.println(count_pairs(arr, brr, N, M, K));``}``}` `// This code is contributed by SURENDRA_GANGWAR`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to count pairs that satisfy``# the given conditions``def` `count_pairs(arr, brr, N, M, K):``    ` `    ``# Stores index of``    ``# the left pointer.``    ``i ``=` `0` `    ``# Stores index of``    ``# the right pointer``    ``j ``=` `0` `    ``# Stores count of total pairs``    ``# that satisfy the conditions``    ``cntPairs ``=` `0` `    ``# Sort arr[] array``    ``arr ``=` `sorted``(arr)` `    ``# Sort brr[] array``    ``brr ``=` `sorted``(brr)` `    ``# Traverse both the array``    ``# and count then pairs``    ``while` `(i < N ``and` `j < M):` `        ``# If the value of``        ``# (brr[j] - arr[i]) exceeds K``        ``if` `(brr[j] ``-` `arr[i] > K):` `            ``# Update cntPairs``            ``cntPairs ``+``=` `(M ``-` `j)` `            ``# Update``            ``i ``+``=` `1``        ``else``:` `            ``# Update j``            ``j ``+``=` `1` `    ``return` `cntPairs` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``5``, ``9``, ``1``, ``8` `]``    ``brr ``=` `[ ``10``, ``12``, ``7``, ``4``, ``2``, ``3` `]``    ``K ``=` `3``    ` `    ``N ``=` `len``(arr)``    ``M ``=` `len``(brr)``    ` `    ``print``(count_pairs(arr, brr, N, M, K))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to implement``// the above approach``using` `System;``class` `GFG{``    ` `// Function to count pairs``// that satisfy the given``// conditions``static` `int` `count_pairs(``int``[] arr, ``int``[] brr,``                       ``int` `N, ``int` `M, ``int` `K)``{``  ``// Stores index of``  ``// the left pointer.``  ``int` `i = 0;` `  ``// Stores index of``  ``// the right pointer``  ``int` `j = 0;` `  ``// Stores count of total pairs``  ``// that satisfy the conditions``  ``int` `cntPairs = 0;` `  ``// Sort arr[] array``  ``Array.Sort(arr);` `  ``// Sort brr[] array``  ``Array.Sort(brr);` `  ``// Traverse both the array``  ``// and count then pairs``  ``while` `(i < N && j < M)``  ``{``    ``// If the value of``    ``// (brr[j] - arr[i])``    ``// exceeds K``    ``if` `(brr[j] - arr[i] > K)``    ``{``      ``// Update cntPairs``      ``cntPairs += (M - j);` `      ``// Update``      ``i++;``    ``}``    ``else``    ``{``      ``// Update j``      ``j++;``    ``}``  ``}``  ``return` `cntPairs;``}``    ` `// Driver code ``static` `void` `Main()``{``  ``int``[] arr = {5, 9, 1, 8};``  ``int``[] brr = {10, 12,``               ``7, 4, 2, 3};``  ``int` `K = 3;``  ``int` `N = arr.Length;``  ``int` `M = brr.Length;``  ``Console.WriteLine(``  ``count_pairs(arr, brr,``              ``N, M, K));``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``
Output:
`6`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up