# Count pairs from two arrays with difference exceeding K

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.

Algorithm

`Initialize a variable sum to zero.Loop through each element of the input array:a. If the current element is even (i.e., its value is divisible by 2 with no remainder), add it to the sum.Return the value of sum.`

## C++

 `#include ` `#include ` `using` `namespace` `std;`   `int` `main() {` `    ``vector<``int``> arr = {5, 9, 1, 8};` `    ``vector<``int``> brr = {10, 12, 7, 4, 2, 3};` `    ``int` `K = 3;` `    ``int` `count = 0;` `    `  `    ``// Traverse the array and generate all possible pairs` `    ``for` `(``int` `i = 0; i < arr.size(); i++) {` `        ``for` `(``int` `j = 0; j < brr.size(); j++) {` `            ``// Check if (brr[j] - arr[i]) > K` `            ``if` `(brr[j] - arr[i] > K) {` `                ``// Increment the counter` `                ``count++;` `            ``}` `        ``}` `    ``}` `    `  `    ``// Print the count` `    ``cout << count << endl;` `    `  `    ``return` `0;` `}`

## Java

 `public` `class` `GFG {` `    ``public` `static` `void` `main(String[] args) {` `        ``int``[] arr = {``5``, ``9``, ``1``, ``8``};` `        ``int``[] brr = {``10``, ``12``, ``7``, ``4``, ``2``, ``3``};` `        ``int` `K = ``3``;` `        ``int` `count = ``0``;`   `        ``// Traverse the array and generate all possible pairs` `        ``for` `(``int` `i = ``0``; i < arr.length; i++) {` `            ``for` `(``int` `j = ``0``; j < brr.length; j++) {` `                ``// Check if (brr[j] - arr[i]) > K` `                ``if` `(brr[j] - arr[i] > K) {` `                    ``// Increment the counter` `                    ``count++;` `                ``}` `            ``}` `        ``}`   `        ``// Print the count` `        ``System.out.println(count);` `    ``}` `}`

## Python

 `arr ``=` `[``5``, ``9``, ``1``, ``8``]` `brr ``=` `[``10``, ``12``, ``7``, ``4``, ``2``, ``3``]` `K ``=` `3`   `count ``=` `0`   `# Traverse the array and generate all possible pairs` `for` `i ``in` `range``(``len``(arr)):` `    ``for` `j ``in` `range``(``len``(brr)):` `        ``# Check if (brr[j] - arr[i]) > K` `        ``if` `brr[j] ``-` `arr[i] > K:` `            ``# Increment the counter` `            ``count ``+``=` `1`   `# Print the count` `print``(count)`

## C#

 `// C# code for above approach` `using` `System;`   `public` `class` `GFG {` `    ``static` `public` `void` `Main() {` `        ``int``[] arr = {5, 9, 1, 8};` `        ``int``[] brr = {10, 12, 7, 4, 2, 3};` `        ``int` `K = 3;` `        ``int` `count = 0;`   `        ``// Traverse the array and generate all possible pairs` `        ``for` `(``int` `i = 0; i < arr.Length; i++) {` `            ``for` `(``int` `j = 0; j < brr.Length; j++) {` `                ``// Check if (brr[j] - arr[i]) > K` `                ``if` `(brr[j] - arr[i] > K) {` `                    ``// Increment the counter` `                    ``count++;` `                ``}` `            ``}` `        ``}`   `        ``// Print the count` `        ``Console.WriteLine(count);` `    ``}` `}`   `// This code is contributed by Utkarsh Kumar`

## Javascript

 `function` `main() {` `  ``let arr = [5, 9, 1, 8];` `  ``let brr = [10, 12, 7, 4, 2, 3];` `  ``let K = 3;` `  ``let count = 0;`   `  ``// Traverse the array and generate all possible pairs` `  ``for` `(let i = 0; i < arr.length; i++) {` `    ``for` `(let j = 0; j < brr.length; j++) {` `      ``// Check if (brr[j] - arr[i]) > K` `      ``if` `(brr[j] - arr[i] > K) {` `        ``// Increment the counter` `        ``count++;` `      ``}` `    ``}` `  ``}`   `  ``// Print the count` `  ``console.log(count);` `}`   `main();` `// This code is contributed by shivhack999`

Output

```6

```

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[0]);` `    ``int` `M = ``sizeof``(brr) / ``sizeof``(brr[0]);` `    ``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)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next