# Count pairs from two arrays with difference exceeding K

Last Updated : 05 Jul, 2023

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)

Previous
Next