Minimum removals from array to make max – min <= K

30 Jun, 2022
Given N integers and K, find the minimum number of elements that should be removed, such that Amax-Amin<=K. After the removal of elements, Amax and Amin is considered among the remaining elements.
Examples: 
Input : a[] = {1, 3, 4, 9, 10, 11, 12, 17, 20} 
          k = 4 
Output : 5 
Explanation: Remove 1, 3, 4 from beginning 
and 17, 20 from the end.

Input : a[] = {1, 5, 6, 2, 8}  K=2
Output : 3
Explanation: There are multiple ways to 
remove elements in this case.
One among them is to remove 5, 6, 8.
The other is to remove 1, 2, 5
Approach: Sort the given elements. Using the greedy approach, the best way is to remove the minimum element or the maximum element and then check if Amax-Amin <= K. There are various combinations of removals that have to be considered. We write a recurrence relation to try every possible combination. There will be two possible ways of removal, either we remove the minimum or we remove the maximum. Let(i...j) be the index of elements left after removal of elements. Initially, we start with i=0 and j=n-1 and the number of elements removed is 0 at the beginning. We only remove an element if a[j]-a[i]>k, the two possible ways of removal are (i+1...j) or (i...j-1). The minimum of the two is considered. Let DPi, j be the number of elements that need to be removed so that after removal a[j]-a[i]<=k. 
Recurrence relation for sorted array:  
DPi, j = 1+ (min(countRemovals(i+1, j), countRemovals(i, j-1))
Below is the implementation of the above idea: 
C++
Java
Python3
C#
PHP
Javascript
// CPP program to find minimum removals// to make max-min <= K#include <bits/stdc++.h>using namespace std; #define MAX 100int dp[MAX][MAX]; // function to check all possible combinations// of removal and return the minimum oneint countRemovals(int a[], int i, int j, int k){    // base case when all elements are removed    if (i >= j)        return 0;     // if condition is satisfied, no more    // removals are required    else if ((a[j] - a[i]) <= k)        return 0;     // if the state has already been visited    else if (dp[i][j] != -1)        return dp[i][j];     // when Amax-Amin>d    else if ((a[j] - a[i]) > k) {         // minimum is taken of the removal        // of minimum element or removal        // of the maximum element        dp[i][j] = 1 + min(countRemovals(a, i + 1, j, k),                           countRemovals(a, i, j - 1, k));    }    return dp[i][j];} // To sort the array and return the answerint removals(int a[], int n, int k){    // sort the array    sort(a, a + n);     // fill all stated with -1    // when only one element    memset(dp, -1, sizeof(dp));    if (n == 1)        return 0;    else        return countRemovals(a, 0, n - 1, k);} // Driver Codeint main(){    int a[] = { 1, 3, 4, 9, 10, 11, 12, 17, 20 };    int n = sizeof(a) / sizeof(a[0]);    int k = 4;    cout << removals(a, n, k);    return 0;}
// Java program to find minimum removals// to make max-min <= Kimport java.util.Arrays; class GFG{    static int MAX=100;    static int dp[][]=new int[MAX][MAX];         // function to check all possible combinations    // of removal and return the minimum one    static int countRemovals(int a[], int i, int j, int k)    {        // base case when all elements are removed        if (i >= j)            return 0;             // if condition is satisfied, no more        // removals are required        else if ((a[j] - a[i]) <= k)            return 0;             // if the state has already been visited        else if (dp[i][j] != -1)            return dp[i][j];             // when Amax-Amin>d        else if ((a[j] - a[i]) > k) {                 // minimum is taken of the removal            // of minimum element or removal            // of the maximum element            dp[i][j] = 1 + Math.min(countRemovals(a, i + 1, j, k),                                    countRemovals(a, i, j - 1, k));        }        return dp[i][j];    }         // To sort the array and return the answer    static int removals(int a[], int n, int k)    {        // sort the array        Arrays.sort(a);             // fill all stated with -1        // when only one element        for(int[] rows:dp)        Arrays.fill(rows,-1);        if (n == 1)            return 0;        else            return countRemovals(a, 0, n - 1, k);    }         // Driver code    public static void main (String[] args)    {        int a[] = { 1, 3, 4, 9, 10, 11, 12, 17, 20 };        int n = a.length;        int k = 4;        System.out.print(removals(a, n, k));    }} // This code is contributed by Anant Agarwal.
# Python program to find# minimum removals to# make max-min <= KMAX = 100dp = [[0 for i in range(MAX)]         for i in range(MAX)]for i in range(0, MAX) :    for j in range(0, MAX) :        dp[i][j] = -1 # function to check all# possible combinations# of removal and return# the minimum onedef countRemovals(a, i, j, k) :     global dp         # base case when all    # elements are removed    if (i >= j) :        return 0     # if condition is satisfied,    # no more removals are required    elif ((a[j] - a[i]) <= k) :        return 0     # if the state has    # already been visited    elif (dp[i][j] != -1) :        return dp[i][j]     # when Amax-Amin>d    elif ((a[j] - a[i]) > k) :         # minimum is taken of        # the removal of minimum        # element or removal of        # the maximum element        dp[i][j] = 1 + min(countRemovals(a, i + 1,                                         j, k),                           countRemovals(a, i,                                         j - 1, k))    return dp[i][j] # To sort the array# and return the answerdef removals(a, n, k) :     # sort the array    a.sort()     # fill all stated    # with -1 when only    # one element    if (n == 1) :        return 0    else :        return countRemovals(a, 0,                             n - 1, k) # Driver Codea = [1, 3, 4, 9, 10,     11, 12, 17, 20]n = len(a)k = 4print (removals(a, n, k)) # This code is contributed by# Manish Shaw(manishshaw1)
// C# program to find minimum// removals to make max-min <= Kusing System; class GFG{    static int MAX = 100;    static int [,]dp = new int[MAX, MAX];         // function to check all    // possible combinations    // of removal and return    // the minimum one    static int countRemovals(int []a, int i,                             int j, int k)    {        // base case when all        // elements are removed        if (i >= j)            return 0;             // if condition is satisfied,        // no more removals are required        else if ((a[j] - a[i]) <= k)            return 0;             // if the state has        // already been visited        else if (dp[i, j] != -1)            return dp[i, j];             // when Amax-Amin>d        else if ((a[j] - a[i]) > k)        {                 // minimum is taken of the            // removal of minimum element            // or removal of the maximum            // element            dp[i, j] = 1 + Math.Min(countRemovals(a, i + 1,                                                  j, k),                                    countRemovals(a, i,                                                  j - 1, k));        }        return dp[i, j];    }         // To sort the array and    // return the answer    static int removals(int []a,                        int n, int k)    {        // sort the array        Array.Sort(a);             // fill all stated with -1        // when only one element        for(int i = 0; i < MAX; i++)        {            for(int j = 0; j < MAX; j++)                dp[i, j] = -1;        }        if (n == 1)            return 0;        else            return countRemovals(a, 0,                                 n - 1, k);    }         // Driver code    static void Main()    {        int []a = new int[]{ 1, 3, 4, 9, 10,                             11, 12, 17, 20 };        int n = a.Length;        int k = 4;        Console.Write(removals(a, n, k));    }} // This code is contributed by// ManishShaw(manishshaw1)
<?php// PHP program to find// minimum removals to// make max-min <= K$MAX = 100;$dp = array(array());for($i = 0; $i < $MAX; $i++){    for($j = 0; $j < $MAX; $j++)        $dp[$i][$j] = -1;} // function to check all// possible combinations// of removal and return// the minimum onefunction countRemovals($a, $i,                       $j, $k){    global $dp;         // base case when all    // elements are removed    if ($i >= $j)        return 0;     // if condition is satisfied,    // no more removals are required    else if (($a[$j] - $a[$i]) <= $k)        return 0;     // if the state has    // already been visited    else if ($dp[$i][$j] != -1)        return $dp[$i][$j];     // when Amax-Amin>d    else if (($a[$j] - $a[$i]) > $k)    {         // minimum is taken of        // the removal of minimum        // element or removal of        // the maximum element        $dp[$i][$j] = 1 + min(countRemovals($a, $i + 1,                                                $j, $k),                              countRemovals($a, $i,                                            $j - 1, $k));    }    return $dp[$i][$j];} // To sort the array// and return the answerfunction removals($a, $n, $k){    // sort the array    sort($a);     // fill all stated with -1    // when only one element    if ($n == 1)        return 0;    else        return countRemovals($a, 0,                             $n - 1, $k);} // Driver Code$a = array(1, 3, 4, 9, 10,           11, 12, 17, 20);$n = count($a);$k = 4;echo (removals($a, $n, $k)); // This code is contributed by// Manish Shaw(manishshaw1)?>
<script>     // JavaScript program to find minimum removals    // to make max-min <= K         let MAX = 100;    let dp = new Array(MAX);    for(let i = 0; i < MAX; i++)    {        dp[i] = new Array(MAX);    }    // function to check all possible combinations    // of removal and return the minimum one    function countRemovals(a,i,j,k)    {        // base case when all elements are removed        if (i >= j)            return 0;         // if condition is satisfied, no more        // removals are required        else if ((a[j] - a[i]) <= k)            return 0;         // if the state has already been visited        else if (dp[i][j] != -1)            return dp[i][j];         // when Amax-Amin>d        else if ((a[j] - a[i]) > k) {             // minimum is taken of the removal            // of minimum element or removal            // of the maximum element            dp[i][j] = 1 + Math.min(countRemovals(a, i + 1, j, k),                            countRemovals(a, i, j - 1, k));        }        return dp[i][j];    }     // To sort the array and return the answer    function removals(a,n,k)    {        // sort the array        a.sort(function(a, b){return a - b});         // fill all stated with -1        // when only one element        for(let i = 0; i < MAX; i++)        {            for(let j = 0; j < MAX; j++)            {                dp[i][j] = -1;            }        }        if (n == 1)            return 0;        else            return countRemovals(a, 0, n - 1, k);    }     // Driver Code     let a = [ 1, 3, 4, 9, 10, 11, 12, 17, 20 ];    let n = a.length;    let k = 4;    document.write(removals(a, n, k)); </script>
5
Time Complexity :O(n2) Auxiliary Space: O(n2)
The solution could be further optimized. The idea is to sort the array in increasing order and traverse through all the elements (let’s say index i) and find the maximum element on its right (index j) such that arr[j] – arr[i] <= k. Thus, the number of elements to be removed becomes n-(j-i+1). The minimum number of elements can be found by taking the minimum of n-(j-i-1) overall i. The value of index j can be found through a binary search between start = i+1 and end = n-1;
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; // Function to find// rightmost index// which satisfies the condition// arr[j] - arr[i] <= kint findInd(int key, int i,            int n, int k, int arr[]){    int start, end, mid, ind = -1;         // Initialising start to i + 1    start = i + 1;         // Initialising end to n - 1    end = n - 1;         // Binary search implementation    // to find the rightmost element    // that satisfy the condition    while (start < end)    {        mid = start + (end - start) / 2;                 // Check if the condition satisfies        if (arr[mid] - key <= k)        {                           // Store the position            ind = mid;                         // Make start = mid + 1            start = mid + 1;        }        else        {            // Make end = mid            end = mid;        }    }         // Return the rightmost position    return ind;} // Function to calculate// minimum number of elements// to be removedint removals(int arr[], int n, int k){    int i, j, ans = n - 1;         // Sort the given array    sort(arr, arr + n);         // Iterate from 0 to n-1    for (i = 0; i < n; i++)    {                 // Find j such that        // arr[j] - arr[i] <= k        j = findInd(arr[i], i, n, k, arr);                 // If there exist such j        // that satisfies the condition        if (j != -1)        {            // Number of elements            // to be removed for this            // particular case is            // (j - i + 1)            ans = min(ans, n - (j - i + 1));        }    }         // Return answer    return ans;} // Driver Codeint main(){    int a[] = {1, 3, 4, 9, 10,               11, 12, 17, 20};    int n = sizeof(a) / sizeof(a[0]);    int k = 4;    cout << removals(a, n, k);    return 0;}
// Java program for the above approachimport java.util.*; class GFG{     // Function to find rightmost index// which satisfies the condition// arr[j] - arr[i] <= kstatic int findInd(int key, int i,                   int n, int k, int arr[]){    int start, end, mid, ind = -1;         // Initialising start to i + 1    start = i + 1;         // Initialising end to n - 1    end = n - 1;         // Binary search implementation    // to find the rightmost element    // that satisfy the condition    while (start < end)    {        mid = start + (end - start) / 2;                 // Check if the condition satisfies        if (arr[mid] - key <= k)        {                         // Store the position            ind = mid;                         // Make start = mid + 1            start = mid + 1;        }        else        {                         // Make end = mid            end = mid;        }    }         // Return the rightmost position    return ind;} // Function to calculate// minimum number of elements// to be removedstatic int removals(int arr[], int n, int k){    int i, j, ans = n - 1;         // Sort the given array    Arrays.sort(arr);         // Iterate from 0 to n-1    for(i = 0; i < n; i++)    {                 // Find j such that        // arr[j] - arr[i] <= k        j = findInd(arr[i], i, n, k, arr);                 // If there exist such j        // that satisfies the condition        if (j != -1)        {                         // Number of elements            // to be removed for this            // particular case is            // (j - i + 1)            ans = Math.min(ans,                           n - (j - i + 1));        }    }         // Return answer    return ans;} // Driver Codepublic static void main(String args[]){    int a[] = { 1, 3, 4, 9, 10,                11, 12, 17, 20 };    int n = a.length;    int k = 4;         System.out.println(removals(a, n, k));}} // This code is contributed by adityapande88
# Python program for the# above approach # Function to find# rightmost index# which satisfies the condition# arr[j] - arr[i] <= kdef findInd(key, i, n,            k, arr):        ind = -1          # Initialising start     # to i + 1     start = i + 1            # Initialising end     # to n - 1     end = n - 1;          # Binary search implementation     # to find the rightmost element     # that satisfy the condition     while (start < end):          mid = int(start +                   (end - start) / 2)                   # Check if the condition          # satisfies          if (arr[mid] - key <= k):                            # Store the position               ind = mid                                # Make start = mid + 1               start = mid + 1          else:               # Make end = mid               end = mid                      # Return the rightmost position     return ind     # Function to calculate# minimum number of elements# to be removeddef removals(arr, n, k):        ans = n - 1          # Sort the given array     arr.sort()          # Iterate from 0 to n-1     for i in range(0, n):                 # Find j such that          # arr[j] - arr[i] <= k          j = findInd(arr[i], i,                      n, k, arr)                     # If there exist such j          # that satisfies the condition          if (j != -1):                            # Number of elements               # to be removed for this               # particular case is               # (j - i + 1)               ans = min(ans, n -                        (j - i + 1))                    # Return answer     return ans     # Driver Codea = [1, 3, 4, 9,     10,11, 12, 17, 20]n = len(a)k = 4print(removals(a, n, k)) # This code is contributed by Stream_Cipher
// C# program for the above approachusing System; class GFG{     // Function to find rightmost index// which satisfies the condition// arr[j] - arr[i] <= kstatic int findInd(int key, int i,                   int n, int k, int[] arr){    int start, end, mid, ind = -1;          // Initialising start to i + 1    start = i + 1;          // Initialising end to n - 1    end = n - 1;          // Binary search implementation    // to find the rightmost element    // that satisfy the condition    while (start < end)    {        mid = start + (end - start) / 2;                  // Check if the condition satisfies        if (arr[mid] - key <= k)        {                         // Store the position            ind = mid;                          // Make start = mid + 1            start = mid + 1;        }        else        {                         // Make end = mid            end = mid;        }    }         // Return the rightmost position    return ind;}  // Function to calculate minimum// number of elements to be removedstatic int removals(int[] arr, int n, int k){    int i, j, ans = n - 1;          // Sort the given array    Array.Sort(arr);          // Iterate from 0 to n-1    for(i = 0; i < n; i++)    {                  // Find j such that        // arr[j] - arr[i] <= k        j = findInd(arr[i], i, n, k, arr);                  // If there exist such j        // that satisfies the condition        if (j != -1)        {                          // Number of elements            // to be removed for this            // particular case is            // (j - i + 1)            ans = Math.Min(ans,                           n - (j - i + 1));        }    }          // Return answer    return ans;} // Driver codestatic void Main(){    int[] a = { 1, 3, 4, 9, 10,                11, 12, 17, 20 };    int n = a.Length;    int k = 4;          Console.Write(removals(a, n, k));}} // This code is contributed by sanjoy_62
<script>    // javascript program for the above approach     // Function to find rightmost index    // which satisfies the condition    // arr[j] - arr[i] <= k    function findInd(key , i , n , k , arr) {        var start, end, mid, ind = -1;         // Initialising start to i + 1        start = i + 1;         // Initialising end to n - 1        end = n - 1;         // Binary search implementation        // to find the rightmost element        // that satisfy the condition        while (start < end) {            mid = start + (end - start) / 2;             // Check if the condition satisfies            if (arr[mid] - key <= k) {                 // Store the position                ind = mid;                 // Make start = mid + 1                start = mid + 1;            }              else {                 // Make end = mid                end = mid;            }        }         // Return the rightmost position        return ind;    }     // Function to calculate    // minimum number of elements    // to be removed    function removals(arr , n , k) {        var i, j, ans = n - 1;         // Sort the given array        arr.sort((a,b)=>a-b);         // Iterate from 0 to n-1        for (i = 0; i < n; i++) {             // Find j such that            // arr[j] - arr[i] <= k            j = findInd(arr[i], i, n, k, arr);             // If there exist such j            // that satisfies the condition            if (j != -1) {                 // Number of elements                // to be removed for this                // particular case is                // (j - i + 1)                ans = Math.min(ans, n - (j - i + 1));            }        }         // Return answer        return ans;    }     // Driver Code         var a = [ 1, 3, 4, 9, 10, 11, 12, 17, 20 ];    var n = a.length;    var k = 4;     document.write(removals(a, n, k)); // This code contributed by Rajput-Ji</script>
5
Time Complexity :O(nlogn) 
Auxiliary Space: O(n)
Approach:
The solution could be further optimized. The idea is to sort the array in increasing order and traverse through all the elements (let’s say index j) and find the minimum element on its left (index i) such that arr[j] – arr[i] <= k and store it in dp[j].Thus, the number of elements to be removed becomes n-(j-i+1). The minimum number of elements can be found by taking the minimum of n-(j-i-1) overall j. The value of index i can be found through its previous dp array element value.
The solution could be further optimized. The idea is to sort the array in increasing order and traverse through all the elements (let’s say index j) and find the minimum element on its left (index i) such that arr[j] – arr[i] <= k and store it in dp[j].
Thus, the number of elements to be removed becomes n-(j-i+1). The minimum number of elements can be found by taking the minimum of n-(j-i-1) overall j. The value of index i can be found through its previous dp array element value.
Below is the implementation of the approach:
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include<bits/stdc++.h>using namespace std; // To sort the array and return the answerint removals(int arr[], int n, int k){     // sort the array  sort(arr, arr + n);  int dp[n];   // fill all stated with -1  // when only one element  for(int i = 0; i < n; i++)    dp[i] = -1;   // as dp[0] = 0 (base case) so min  // no of elements to be removed are  // n-1 elements  int ans = n - 1;  dp[0] = 0;  for (int i = 1; i < n; i++)  {    dp[i] = i;    int j = dp[i - 1];    while (j != i && arr[i] - arr[j] > k)    {      j++;    }    dp[i] = min(dp[i], j);    ans = min(ans, (n - (i - j + 1)));  }  return ans;} // Driver code   int main(){  int a[] = { 1, 3, 4, 9, 10, 11, 12, 17, 20 };  int n = sizeof(a) / sizeof(a[0]);  int k = 4;  cout<<removals(a, n, k);  return 0;} // This code is contributed by Balu Nagar
// Java program for the above approachimport java.io.*;import java.util.*; class GFG {       // To sort the array and return the answer    static int removals(int arr[], int n, int k)    {        // sort the array        Arrays.sort(arr);         // fill all stated with -1        // when only one element        int dp[] = new int[n];        Arrays.fill(dp, -1);               // as dp[0] = 0 (base case) so min        // no of elements to be removed are        // n-1 elements        int ans = n - 1;        dp[0] = 0;               // Iterate from 1 to n - 1        for (int i = 1; i < n; i++) {            dp[i] = i;            int j = dp[i - 1];            while (j != i && arr[i] - arr[j] > k) {                j++;            }            dp[i] = Integer.min(dp[i], j);            ans = Integer.min(ans, (n - (i - j + 1)));        }        return ans;    }     // Driver code    public static void main(String[] args)    {        int a[] = { 1, 3, 4, 9, 10, 11, 12, 17, 20 };        int n = a.length;        int k = 4;        System.out.print(removals(a, n, k));    }}
# Python3 program for the above approach # To sort the array and return the answerdef removals(arr, n, k):       # sort the array  arr.sort()  dp = [0 for i in range(n)]   # Fill all stated with -1  # when only one element  for i in range(n):    dp[i] = -1   # As dp[0] = 0 (base case) so min  # no of elements to be removed are  # n-1 elements  ans = n - 1  dp[0] = 0     for i in range(1, n):    dp[i] = i    j = dp[i - 1]         while (j != i and arr[i] - arr[j] > k):      j += 1           dp[i] = min(dp[i], j)    ans = min(ans, (n - (i - j + 1)))       return ans # Driver code   a = [ 1, 3, 4, 9, 10, 11, 12, 17, 20 ]n = len(a)k = 4 print(removals(a, n, k)) # This code is contributed by rohan07
// C# program for the above approachusing System; class GFG{     // To sort the array and return the answerstatic int removals(int[] arr, int n, int k){         // Sort the array    Array.Sort(arr);    int[] dp = new int[n];     // Fill all stated with -1    // when only one element    for(int i = 0; i < n; i++)        dp[i] = -1;     // As dp[0] = 0 (base case) so min    // no of elements to be removed are    // n-1 elements    int ans = n - 1;    dp[0] = 0;         // Iterate from 1 to n - 1    for(int i = 1; i < n; i++)    {        dp[i] = i;        int j = dp[i - 1];                 while (j != i && arr[i] - arr[j] > k)        {            j++;        }        dp[i] = Math.Min(dp[i], j);        ans = Math.Min(ans, (n - (i - j + 1)));    }    return ans;} // Driver codestatic public void Main(){    int[] a = { 1, 3, 4, 9, 10, 11, 12, 17, 20 };    int n = a.Length;    int k = 4;     Console.Write(removals(a, n, k));}} // This code is contributed by lokeshpotta20
<script> // JavaScript program for the above approach // To sort the array and return the answerfunction removals(arr, n, k){     // sort the array  arr.sort((a,b)=>a-b);  var dp = Array(n);   // fill all stated with -1  // when only one element  for(var i = 0; i < n; i++)    dp[i] = -1;   // as dp[0] = 0 (base case) so min  // no of elements to be removed are  // n-1 elements  var ans = n - 1;  dp[0] = 0;  for (var i = 1; i < n; i++)  {    dp[i] = i;    var j = dp[i - 1];    while (j != i && arr[i] - arr[j] > k)    {      j++;    }    dp[i] = Math.min(dp[i], j);    ans = Math.min(ans, (n - (i - j + 1)));  }  return ans;} // Driver code   var a = [1, 3, 4, 9, 10, 11, 12, 17, 20];var n = a.length;var k = 4;document.write( removals(a, n, k)); </script>
5
Time Complexity: O(nlog n). As outer loop is going to make n iterations. And the inner loop iterates at max n times for all outer iterations. Because we start value of j from dp[i-1] and loops it until it reaches i and then for the next element we again start from the previous dp[i] value. So the total time complexity is O(n) if we don’t consider the complexity of the sorting as it is not considered in the above solution as well.
Auxiliary Space: O(n)
The solution could be further optimized. It can be done in Auxiliary Space: O(1). The idea is to first sort the array in ascending order. The keep 2 pointers, say i and j, where j iterates from index 1 to index n-1 and keeps track of ending subarray with the difference in max and min less than k, and i keeps the track of starting index of the subarray. If we find that a[j] – a[i[ <=k (means the i to j subarray is valid) we update the length from i to j in a variable to track of max length so far. Else, we update the starting index i with i+1. 
At first it seems that subarrays from i to j are ignored, but obviously their lengths are less than i to j subarray, so we don’t care about them.
C++
Java
Python
C#
Javascript
// C++ program for the above approach#include<bits/stdc++.h>using namespace std; int removal(int a[], int n, int k){    // Sort the Array; Time complexity:O(nlogn)    sort(a, a + n);     // to store the max length of    // array with difference <= k    int maxLen = INT_MIN;    int i = 0;    // J goes from 1 to n-1 in n-2 iterations    // Thus time complexity of below loop is O(n)    for (int j = i + 1; j < n && i < n; j++) {        // if the subarray from i to j index is valid        // the store it's length        if (a[j] - a[i] <= k) {            maxLen = max(maxLen, j - i + 1);        }        // if subarray difference exceeds k        // change starting position, i.e. i        else {            i++;        }    }    // no. of elements need to be removed is    // Length of array - max subarray with diff <= k    int removed = n - maxLen;    return removed;} //Driver Codeint main(){    int a[] = { 1, 3, 4, 9, 10, 11, 12, 17, 20 };    int n = sizeof(a) / sizeof(a[0]);    int k = 4;    cout << removal(a, n, k);    return 0;}
// Java program for the above approachimport java.io.*;import java.util.*; class GFG {         public static int removal(int[] a, int n, int k){        //Sort the Array; Time complexity:O(nlogn)        Arrays.sort(a);                 // to store the max length of        // array with difference <= k        int max = Integer.MIN_VALUE;        int i=0;        // J goes from 1 to n-1 in n-2 iterations        // Thus time complexity of below loop is O(n)        for(int j=i+1;j<n && i<n;j++){            // if the subarray from i to j index is valid            // the store it's length            if(a[j]-a[i] <= k){                max = Math.max(max, j-i+1);            }            // if subarray difference exceeds k            // change starting position, i.e. i            else{                i++;            }        }        // no. of elements need to be removed is        // Length of array - max subarray with diff <= k        int removed = n-max;        return removed;    }       //Driver Code    public static void main (String[] args) {        int a[] = { 1, 3, 4, 9, 10, 11, 12, 17, 20 };        int n = a.length;        int k = 4;        System.out.print(removal(a, n, k));    }}
# Python program for the above approachdef removal(a, n, k):    # sort the array    a.sort()    # to store the max length of    # array with difference <= k    maxLen = 0    # pointer to keep track of starting of each subarray    i = 0    for j in range(i+1, n):        # if the subarray from i to j index is valid        # the store it's length        if a[j]-a[i] <= k:            maxLen = max(maxLen, j-i+1)        # if subarray difference exceeds k        # change starting position, i.e. i        else:            i = i+1                     if i >= n:            break    remove = n-maxLen    return remove  # Driver Codea = [1, 3, 4, 9, 10, 11, 12, 17, 20]n = len(a)k = 4 print(removal(a, n, k))
// C# program for the above approachusing System; class GFG {     static int removal(int[] a, int n, int k)    {               // Sort the Array; Time complexity:O(nlogn)        Array.Sort(a);         // to store the max length of        // array with difference <= k        int max = Int32.MinValue;        int i = 0;               // J goes from 1 to n-1 in n-2 iterations        // Thus time complexity of below loop is O(n)        for (int j = i + 1; j < n && i < n; j++)        {                       // if the subarray from i to j index is valid            // the store it's length            if (a[j] - a[i] <= k) {                max = Math.Max(max, j - i + 1);            }                       // if subarray difference exceeds k            // change starting position, i.e. i            else {                i++;            }        }               // no. of elements need to be removed is        // Length of array - max subarray with diff <= k        int removed = n - max;        return removed;    }     // Driver Code    public static void Main()    {        int[] a = { 1, 3, 4, 9, 10, 11, 12, 17, 20 };        int n = a.Length;        int k = 4;        Console.Write(removal(a, n, k));    }} // This code is contributed by Samim Hossain Mondal.
<script> // JavaScript program for the above approachfunction removal(a, n, k){     // sort the array    a.sort((a,b)=>a-b)         // to store the max length of    // array with difference <= k    let maxLen = 0;         // pointer to keep track of starting of each subarray    let i = 0;    for(let j = i + 1; j < n; j++)    {             // if the subarray from i to j index is valid        // the store it's length        if(a[j]-a[i] <= k){            maxLen = Math.max(maxLen, j-i+1);        }                 // if subarray difference exceeds k        // change starting position, i.e. i        else i++;        if(i >= n)break;    }                 let remove = n-maxLen;    return remove;} // Driver Codelet a = [1, 3, 4, 9, 10, 11, 12, 17, 20];let n = a.length;let k = 4; document.write(removal(a, n, k),"</br>") // This code is contributed by shinjanpatra </script>
5
Time Complexity: O(nlogn) For sorting the array, we require O(nlogn) time, and no extra space. And for calculating we only traverse the loop once, thus it has O(n) time complexity. So, overall time complexity is O(nlogn).
Auxiliary Space: O(1)
Approach: 
Here we are applying sliding window, our will maintain a[max]-a[min]<=k. First, ascending order should be used to sort the array. The maintain two pointers, let’s call them I and j, j iterating from index 1 to index n-1 and keeping track of the ending subarray with the difference in max and min smaller than k, and I keeping track of the initial index of the subarray. We update the length from I to j in a variable to track the maximum length thus far if we discover that a[j] – a[i]=k (meaning the I to j subarray is legitimate). If not, we add i+1 to the beginning index i.
C++
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; int removal(int a[], int n, int k){    // Code here    // Sort the Array; Time complexity:O(nlogn)    sort(a, a + n);    int diff= 0; // to store difference of max(a) and min(a)    int ans = 0; // to store maximum length of array with length <=k     // use sliding window to iterate array, maintaing two    // pointers for desired subarray    // which starting from index j and ending with index i    for (int i = 0, j = 0; i < n; i++) {        int diff = a[i] - a[j];        // as array is already sorted, if difference exceeds        // k we will move starting pointer forward        while (i >= j && diff > k) {            diff = a[i] - a[++j];        }        ans = max(ans, i - j + 1);    }    return n - ans;}// Driver Codeint main(){    int a[] = { 1, 3, 4, 9, 10, 11, 12, 17, 20 };    int n = sizeof(a) / sizeof(a[0]);    int k = 4;    cout << removal(a, n, k);    return 0;} // This code is contributed by Gaurav Garg
5
Time complexity: O(nlogn)
Auxiliary Space: O(1)
manishshaw1
srijankhatri98
Stream_Cipher
adityapande88
vikas_motiani
balunagar
sanjoy_62
rohan07
Rajput-Ji
importantly
sharmaanmol313
vaibhavrabadiya117
lokeshpotta20
gabaa406
ayushtiwari26402
as5853535
shinjanpatra
samim2000
256gauravgarg
Arrays
Dynamic Programming
Arrays
Dynamic Programming
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.