Skip to content
Related Articles

Related Articles

Count maximum elements of an array whose absolute difference does not exceed K

View Discussion
Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 24 Apr, 2022
View Discussion
Improve Article
Save Article

Given an array A and positive integer K. The task is to find maximum number of elements for which the absolute difference of any of the pair does not exceed K.
Examples: 
 

Input: A[] = {1, 26, 17, 12, 15, 2}, K = 5 
Output:
There are maximum 3 values so that the absolute difference of each pair 
does not exceed K(K=5) ie., {12, 15, 17}
Input: A[] = {1, 2, 5, 10, 8, 3}, K = 4 
Output:
There are maximum 4 values so that the absolute difference of each pair 
does not exceed K(K=4) ie., {1, 2, 3, 5} 
 

 

Approach: 
 

  1. Sort the given Array in ascending order.
  2. Iterate from index i = 0 to n.
  3. For every A[i] count how many values which are in range A[i] to A[i] + K 
    ie., A[i]<= A[j] <= A[i]+K
  4. Return Max Count

Below is the implementation of the above approach:
 

C++




// C++ implementation of the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the maximum elements
// in which absolute difference of any pair
// does not exceed K
int maxCount(int A[], int N, int K)
{
    int maximum = 0;
    int i = 0, j = 0;
    int start = 0;
    int end = 0;
 
    // Sort the Given array
    sort(A, A + N);
 
    // Find max elements
    for (i = 0; i < N; i++) {
 
        // Count all elements which are in range
        // A[i] to A[i] + K
        while (j < N && A[j] <= A[i] + K)
            j++;
        if (maximum < (j - i)) {
            maximum = (j - i);
            start = i;
            end = j;
        }
    }
 
    // Return the max count
    return maximum;
}
 
// Driver code
int main()
{
    int A[] = { 1, 26, 17, 12, 15, 2 };
    int N = sizeof(A) / sizeof(A[0]);
    int K = 5;
    cout << maxCount(A, N, K);
 
    return 0;
}

Java




// Java implementation of the approach
import java.util.*;
 
class GFG
{
     
// Function to return the maximum elements
// in which absolute difference of any pair
// does not exceed K
static int maxCount(int A[], int N, int K)
{
    int maximum = 0;
    int i = 0, j = 0;
    int start = 0;
    int end = 0;
 
    // Sort the Given array
    Arrays.sort(A);
 
    // Find max elements
    for (i = 0; i < N; i++)
    {
 
        // Count all elements which are in range
        // A[i] to A[i] + K
        while (j < N && A[j] <= A[i] + K)
            j++;
        if (maximum < (j - i))
        {
            maximum = (j - i);
            start = i;
            end = j;
        }
    }
 
    // Return the max count
    return maximum;
}
 
// Driver code
public static void main(String[] args)
{
    int A[] = { 1, 26, 17, 12, 15, 2 };
    int N = A.length;
    int K = 5;
    System.out.println(maxCount(A, N, K));
}
}
 
// This code has been contributed by 29AjayKumar

Python3




# Python3 implementation of the approach
 
def maxCount(A, N, K):
 
    maximum = 0
    start = 0
    end = 0
    j = 0
     
    # Sort the Array
    A.sort()
     
    # Find max elements
    for i in range(0, N):
        while(j < N and A[j] <= A[i] + K):
            j += 1
        if maximum < (j - i ):
            maximum = (j - i)
            start = i;
            end = j;
 
    # Return the maximum
    return maximum
 
# Driver code
A = [1, 26, 17, 12, 15, 2]
N = len(A)
K = 5
 
print(maxCount(A, N, K))

C#




// C# implementation of the approach
using System;
 
class GFG
{
     
// Function to return the maximum elements
// in which absolute difference of any pair
// does not exceed K
static int maxCount(int []A, int N, int K)
{
    int maximum = 0;
    int i = 0, j = 0;
    int start = 0;
    int end = 0;
 
    // Sort the Given array
    Array.Sort(A);
 
    // Find max elements
    for (i = 0; i < N; i++)
    {
 
        // Count all elements which are in range
        // A[i] to A[i] + K
        while (j < N && A[j] <= A[i] + K)
            j++;
        if (maximum < (j - i))
        {
            maximum = (j - i);
            start = i;
            end = j;
        }
    }
 
    // Return the max count
    return maximum;
}
 
// Driver code
public static void Main()
{
    int []A = { 1, 26, 17, 12, 15, 2 };
    int N = A.Length;
    int K = 5;
    Console.Write(maxCount(A, N, K));
}
}
 
/* This code contributed by PrinciRaj1992 */

PHP




<?php
// PHP implementation of the above approach
 
// Function to return the maximum
// elements in which absolute difference
// of any pair does not exceed K
function maxCount($A, $N, $K)
{
    $maximum = 0;
    $i = 0;
    $j = 0;
    $start = 0;
    $end = 0;
 
    // Sort the Given array
    sort($A);
 
    // Find max elements
    for ($i = 0; $i < $N; $i++)
    {
 
        // Count all elements which
        // are in range A[i] to A[i] + K
        while ($j < $N &&
               $A[$j] <= $A[$i] + $K)
            $j++;
        if ($maximum < ($j - $i))
        {
            $maximum = ($j - $i);
            $start = $i;
            $end = $j;
        }
    }
 
    // Return the max count
    return $maximum;
}
 
// Driver code
$A = array( 1, 26, 17, 12, 15, 2 );
$N = Count($A);
$K = 5;
echo maxCount($A, $N, $K);
 
// This code is contributed
// by Arnab Kundu
?>

Javascript




<script>
 
// JavaScript implementation of the above approach
 
// Function to return the maximum elements
// in which absolute difference of any pair
// does not exceed K
function maxCount(A, N, K)
{
    var maximum = 0;
    var i = 0, j = 0;
    var start = 0;
    var end = 0;
 
    // Sort the Given array
    A.sort((a,b)=> a-b)
 
    // Find max elements
    for (i = 0; i < N; i++) {
 
        // Count all elements which are in range
        // A[i] to A[i] + K
        while (j < N && A[j] <= A[i] + K)
            j++;
        if (maximum < (j - i)) {
            maximum = (j - i);
            start = i;
            end = j;
        }
    }
 
    // Return the max count
    return maximum;
}
 
// Driver code
var A = [1, 26, 17, 12, 15, 2 ];
var N = A.length;
var K = 5;
document.write( maxCount(A, N, K));
 
 
</script>

Output: 

3

 

Time Complexity: O(N logN), where N*logN is the time required to sort the given array
Auxiliary Space: O(1), no extra space required


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!