Pairs with Difference less than K

Given an array of n integers, We need to find all pairs with a difference less than k

Examples :

Input : a[] = {1, 10, 4, 2}
        K = 3
Output : 2
We can make only two pairs 
with difference less than 3.
(1, 2) and (4, 2)

Input : a[] = {1, 8, 7}
        K = 7
Output : 2
Pairs with difference less than 7
are (1, 7) and (8, 7)

Method 1 (Simple): Run two nested loops. The outer loop picks every element x one by one. The inner loop considers all elements after x and checks if the difference is within limits or not.  

Implementation:

C#

// C# code to find count of Pairs
//  with difference less than K.
using System;

class GFG {

    // Function to count pairs
    static int countPairs(int []a, int n,
                          int k)
    {
        int res = 0;
        for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
            if (Math.Abs(a[j] - a[i]) < k)
                res++;

        return res;
    }

    // Driver code
    public static void Main ()
    {
        int []a = {1, 10, 4, 2};
        int k = 3;
        int n = a.Length;
        Console.WriteLine(countPairs(a, n, k));

    }
}

// This code is contributed by vt_m.

Output

2

Time Complexity: O(n²) 
Auxiliary Space: O(1)

Method 2 (Sorting): First we sort the array. Then we start from the first element and keep considering pairs while the difference is less than k. If we stop the loop when we find a difference more than or equal to k and move to the next element.  

Implementation:

C++

// C++ code to find count of Pairs with
// difference less than K.
#include <bits/stdc++.h>
using namespace std;

int countPairs(int a[], int n, int k)
{
    // to sort the array.
    sort(a, a + n);

    int res = 0;
    for (int i = 0; i < n; i++) {

        // Keep incrementing result while
        // subsequent elements are within
        // limits.
        int j = i+1;
        while (j < n && a[j] - a[i] < k) {
            res++;
            j++;
        }
    }
    return res;
}

// Driver code
int main()
{
    int a[] =  {1, 10, 4, 2};
    int k = 3;
    int n = sizeof(a) / sizeof(a[0]);
    cout << countPairs(a, n, k) << endl;
    return 0;
}

C#

// C# code to find count of Pairs
// with difference less than K.
using System;

class GFG {

    // Function to count pairs
    static int countPairs(int []a, int n,
                          int k)
    {

        // to sort the array.
        Array.Sort(a);

        int res = 0;
        for (int i = 0; i < n; i++)
        {

            // Keep incrementing result while
            // subsequent elements are within
            // limits.
            int j = i + 1;
            while (j < n && a[j] - a[i] < k)
            {
                res++;
                j++;
            }
        }
        return res;
    }

    // Driver code
    public static void Main ()
    {
        int []a = {1, 10, 4, 2};
        int k = 3;
        int n = a.Length;
        Console.WriteLine(countPairs(a, n, k));
    }
}

// This code is contributed by vt_m.

PHP

<?php
// PHP code to find count of
// Pairs with difference less than K.

function countPairs( $a, $n, $k)
{
    // to sort the array.
    sort($a);

    $res = 0;
    for ( $i = 0; $i < $n; $i++)
    {

        // Keep incrementing result
        // while subsequent elements
        // are within limits.
        $j = $i + 1;
        while ($j < $n and
               $a[$j] - $a[$i] < $k)
        {
            $res++;
            $j++;
        }
    }
    return $res;
}

// Driver code
$a = array(1, 10, 4, 2);
$k = 3;
$n = count($a);
echo countPairs($a, $n, $k);

// This code is contributed by anuj_67.
?>

Javascript

<script>

// JavaScript code to find count of Pairs with
// difference less than K.
function countPairs(a, n, k)
{

    // To sort the array.
    a.sort((a, b) => a - b);

    let res = 0;
    for(let i = 0; i < n; i++)
    {

        // Keep incrementing result while
        // subsequent elements are within
        // limits.
        let j = i + 1;
        while (j < n && a[j] - a[i] < k)
        {
            res++;
            j++;
        }
    }
    return res;
}

// Driver code
let a = [ 1, 10, 4, 2 ];
let k = 3;
let n = a.length;

document.write(countPairs(a, n, k) + "<br>");

// This code is contributed by Surbhi Tyagi.

</script>

Output

2

Time Complexity: O(res) where res is the number of pairs in output. Note that in the worst case this also takes O(n²) time but works much better in general.

Space Complexity: O(1) as no extra space has been used.

Method 3 (Using lower_bound):

The problem can be efficiently solved using the lower_bound function in O(n*log(n)) time complexity. 

The idea is to first sort the elements of the array and then for each element a[i], we will find all such elements which are on the right side of a[i] and whose difference with a[i] is less than k. This can be evaluated by searching for all elements which have a value less than a[i]+k. And this can be easily evaluated with the help of the lower_bound function in O(log(n)) time for each element.

Illustrative example:

Given: a[] = {1, 10, 4, 2} and k=3
Array after sorting: a[] = {1, 2, 4, 10}
For 1, all elements on right side of 1 which are less than 1+3=4 -> {2}
For 2, all elements on right side of 2 which are less than 2+3=5 -> {4}
For 4,  all elements on right side of 4 which are less than 4+3=7 -> {}
For 10, all elements on right side of 10 which are less than 10+3=13 -> {}
So total 2 such elements we found, hence answer = 2.

Approach: 

1. Sort the given array.
2. Iterate through each element and store a[i]+k in val for index i.
3.  Then using the lower_bound function we will find the index of the first occurrence of elements which is greater than or equal to val.
4. After this, we will add the count of all pairs for a[i] by finding the difference between the index which is found using the lower bound function and current index i.

Below is the implementation of the above approach.

Output

2

Time complexity: O(n*log(n))
Auxiliary Space: O(1)

If you like GeeksforGeeks and write.geeksforgeeks.org”>write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org.