# Count pairs in an array such that the absolute difference between them is ≥ K

Given an array arr[] and an integer K, the task is to find the count of pairs (arr[i], arr[j]) from the array such that |arr[i] – arr[j]| ≥ K. Note that (arr[i], arr[j]) and arr[j], arr[i] will be counted only once.

Examples:

Input: arr[] = {1, 2, 3, 4}, K = 2
Output: 3
All valid pairs are (1, 3), (1, 4) and (2, 4)

Input: arr[] = {7, 4, 12, 56, 123}, K = 50
Output: 5

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: Sort the given array. Now for every element arr[i], find the first element on the right arr[j] such that (arr[j] – arr[i]) ≥ K. This is because after this element, every element will satisfy the same condition with arr[i] as the array is sorted and the count of elements that will make a valid pair with arr[i] will be (N – j) where N is the size of the given array.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the count of required pairs ` `int` `count(``int` `arr[], ``int` `n, ``int` `k) ` `{ ` ` `  `    ``// Sort the given array ` `    ``sort(arr, arr + n); ` ` `  `    ``// To store the required count ` `    ``int` `cnt = 0; ` `    ``int` `i = 0, j = 1; ` ` `  `    ``while` `(i < n && j < n) { ` ` `  `        ``// Update j such that it is always > i ` `        ``j = (j <= i) ? (i + 1) : j; ` ` `  `        ``// Find the first element arr[j] such that ` `        ``// (arr[j] - arr[i]) >= K ` `        ``// This is because after this element, all ` `        ``// the elements will have absolute differecne ` `        ``// with arr[i] >= k and the count of ` `        ``// valid pairs will be (n - j) ` `        ``while` `(j < n && (arr[j] - arr[i]) < k) ` `            ``j++; ` ` `  `        ``// Update the count of valid pairs ` `        ``cnt += (n - j); ` ` `  `        ``// Get to the next element to repeat the steps ` `        ``i++; ` `    ``} ` ` `  `    ``// Return the count ` `    ``return` `cnt; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 1, 2, 3, 4 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``int` `k = 2; ` ` `  `    ``cout << count(arr, n, k); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `import` `java.util.*; ` ` `  `class` `solution ` `{ ` ` `  `// Function to return the count of required pairs ` `static` `int` `count(``int` `arr[], ``int` `n, ``int` `k) ` `{ ` ` `  `    ``// Sort the given array ` `    ``Arrays.sort(arr); ` ` `  `    ``// To store the required count ` `    ``int` `cnt = ``0``; ` `    ``int` `i = ``0``, j = ``1``; ` ` `  `    ``while` `(i < n && j < n) { ` ` `  `        ``// Update j such that it is always > i ` `        ``j = (j <= i) ? (i + ``1``) : j; ` ` `  `        ``// Find the first element arr[j] such that ` `        ``// (arr[j] - arr[i]) >= K ` `        ``// This is because after this element, all ` `        ``// the elements will have absolute differecne ` `        ``// with arr[i] >= k and the count of ` `        ``// valid pairs will be (n - j) ` `        ``while` `(j < n && (arr[j] - arr[i]) < k) ` `            ``j++; ` ` `  `        ``// Update the count of valid pairs ` `        ``cnt += (n - j); ` ` `  `        ``// Get to the next element to repeat the steps ` `        ``i++; ` `    ``} ` ` `  `    ``// Return the count ` `    ``return` `cnt; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `arr[] = { ``1``, ``2``, ``3``, ``4` `}; ` `    ``int` `n = arr.length; ` `    ``int` `k = ``2``; ` ` `  `    ``System.out.println(count(arr, n, k)); ` ` `  `} ` `} `

## Python3

 `# Python3 implementation of the approach  ` ` `  `# Function to return the count of required pairs  ` `def` `count(arr, n, k) : ` ` `  `    ``# Sort the given array  ` `    ``arr.sort();  ` ` `  `    ``# To store the required count  ` `    ``cnt ``=` `0``;  ` `    ``i ``=` `0``; j ``=` `1``;  ` ` `  `    ``while` `(i < n ``and` `j < n) : ` ` `  `        ``# Update j such that it is always > i  ` `        ``if` `j <``=` `i : ` `            ``j ``=` `i ``+` `1` `        ``else` `: ` `            ``j ``=` `j ` ` `  `        ``# Find the first element arr[j] such that  ` `        ``# (arr[j] - arr[i]) >= K  ` `        ``# This is because after this element, all  ` `        ``# the elements will have absolute differecne  ` `        ``# with arr[i] >= k and the count of  ` `        ``# valid pairs will be (n - j)  ` `        ``while` `(j < n ``and` `(arr[j] ``-` `arr[i]) < k) : ` `            ``j ``+``=` `1``;  ` ` `  `        ``# Update the count of valid pairs  ` `        ``cnt ``+``=` `(n ``-` `j);  ` ` `  `        ``# Get to the next element to repeat the steps  ` `        ``i ``+``=` `1``;  ` ` `  `    ``# Return the count  ` `    ``return` `cnt;  ` ` `  ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``arr ``=` `[ ``1``, ``2``, ``3``, ``4` `];  ` `    ``n ``=` `len``(arr);  ` `    ``k ``=` `2``;  ` ` `  `    ``print``(count(arr, n, k));  ` `     `  `# This code is contributed by AnkitRai01 `

## C#

 `// C# implementation of the approach ` `using` `System; ` ` `  `class` `GFG ` `{ ` `     `  `// Function to return the count of required pairs ` `static` `int` `count(``int` `[]arr, ``int` `n, ``int` `k) ` `{ ` ` `  `    ``// Sort the given array ` `    ``Array.Sort(arr); ` ` `  `    ``// To store the required count ` `    ``int` `cnt = 0; ` `    ``int` `i = 0, j = 1; ` ` `  `    ``while` `(i < n && j < n)  ` `    ``{ ` ` `  `        ``// Update j such that it is always > i ` `        ``j = (j <= i) ? (i + 1) : j; ` ` `  `        ``// Find the first element arr[j] such that ` `        ``// (arr[j] - arr[i]) >= K ` `        ``// This is because after this element, all ` `        ``// the elements will have absolute differecne ` `        ``// with arr[i] >= k and the count of ` `        ``// valid pairs will be (n - j) ` `        ``while` `(j < n && (arr[j] - arr[i]) < k) ` `            ``j++; ` ` `  `        ``// Update the count of valid pairs ` `        ``cnt += (n - j); ` ` `  `        ``// Get to the next element to repeat the steps ` `        ``i++; ` `    ``} ` ` `  `    ``// Return the count ` `    ``return` `cnt; ` `} ` ` `  `// Driver code ` `static` `public` `void` `Main () ` `{ ` `     `  `    ``int` `[]arr = { 1, 2, 3, 4 }; ` `    ``int` `n = arr.Length; ` `    ``int` `k = 2; ` ` `  `    ``Console.Write(count(arr, n, k)); ` ` `  `} ` `} ` ` `  `// This code is contributed by jit_t. `

Output:

```3
```

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.