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

• Difficulty Level : Medium
• Last Updated : 11 Nov, 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 :
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

Recommended Practice

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++

 `// CPP program to find minimum removals``// to make max-min <= K``#include ``using` `namespace` `std;` `#define MAX 100``int` `dp[MAX][MAX];` `// function to check all possible combinations``// of removal and return the minimum one``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 + 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``int` `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 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;``}`

## Java

 `// Java program to find minimum removals``// to make max-min <= K``import` `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.`

## Python3

 `# Python program to find``# minimum removals to``# make max-min <= K``MAX` `=` `100``dp ``=` `[[``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 one``def` `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 answer``def` `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 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``# Manish Shaw(manishshaw1)`

## C#

 `// C# program to find minimum``// removals to make max-min <= K``using` `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

 `= ``\$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 answer``function` `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)``?>`

## Javascript

 ``

Output

`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++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find``// rightmost index``// which satisfies the condition``// arr[j] - arr[i] <= k``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 removed``int` `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 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;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{``    ` `// Function to find rightmost index``// which satisfies the condition``// arr[j] - arr[i] <= k``static` `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 removed``static` `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 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.println(removals(a, n, k));``}``}` `// This code is contributed by adityapande88`

## Python3

 `# Python program for the``# above approach` `# Function to find``# rightmost index``# which satisfies the condition``# arr[j] - arr[i] <= k``def` `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 removed``def` `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 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 Stream_Cipher`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{``    ` `// Function to find rightmost index``// which satisfies the condition``// arr[j] - arr[i] <= k``static` `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 removed``static` `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 code``static` `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`

## Javascript

 ``

Output

`5`

Time Complexity :O(nlogn)
Auxiliary Space: O(n)

Approach:

1. 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].
2. 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++

 `// C++ program for the above approach``#include``using` `namespace` `std;` `// To sort the array and return the answer``int` `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<

## Java

 `// Java program for the above approach``import` `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

 `# Python3 program for the above approach` `# To sort the array and return the answer``def` `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#

 `// C# program for the above approach``using` `System;` `class` `GFG{``    ` `// To sort the array and return the answer``static` `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 code``static` `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`

## Javascript

 ``

Output

`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)

## Space Optimised Approach

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++

 `// C++ program for the above approach``#include``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 0 to n-1``    ``// Thus time complexity of below loop is O(n)``    ``for` `(``int` `j = 0; 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 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 << removal(a, n, k);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `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 0 to n-1.``        ``// Thus time complexity of below loop is O(n)``        ``for``(``int` `j=``0``;j

## Python

 `# Python program for the above approach``def` `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``(``0``, 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 Code``a ``=` `[``1``, ``3``, ``4``, ``9``, ``10``, ``11``, ``12``, ``17``, ``20``]``n ``=` `len``(a)``k ``=` `4` `print``(removal(a, n, k))`

## C#

 `// C# program for the above approach``using` `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 = 0; 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.`

## Javascript

 ``

Output

`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 ``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, maintaining 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 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 << removal(a, n, k);``    ``return` `0;``}` `// This code is contributed by Gaurav Garg`

## Java

 `// JAVA program for the above approach``import` `java.util.*;``class` `GFG {``  ``public` `static` `int` `removal(``int``[] a, ``int` `n, ``int` `k)``  ``{` `    ``// Code here``    ``// Sort the Array; Time complexity:O(nlogn)``    ``Arrays.sort(a);``    ``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, maintaining``    ``// two pointers for desired subarray which starting``    ``// from index j and ending with index i``    ``for` `(``int` `i = ``0``, j = ``0``; i < n; i++)``    ``{``      ``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 = Math.max(ans, i - j + ``1``);``    ``}``    ``return` `n - ans;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `a[]``      ``= ``new` `int``[] { ``1``, ``3``, ``4``, ``9``, ``10``, ``11``, ``12``, ``17``, ``20` `};``    ``int` `n = a.length;``    ``int` `k = ``4``;``    ``System.out.print(removal(a, n, k));``  ``}``}` `// This code is contributed by Taranpreet`

## Python3

 `# Python program for the above approach``def` `removal(a, n, k):` `  ``# Sort the Array``  ``a.sort()` `  ``diff ``=` `0`  `# to store difference of max(a) and min(a)``  ``ans ``=` `0`  `# to store maximum length of array with length <= k` `  ``j ``=` `0` `  ``# use sliding window to iterate array, maintaining``  ``# two pointers for desired subarray which starting``  ``# from index j and ending with index i``  ``for` `i ``in` `range``(n):``    ``diff ``=` `a[i] ``-` `a[j]` `    ``# as array is already sorted, if difference``    ``# exceeds k we will move starting pointer``    ``# forward``    ``while``(i >``=` `j ``and` `diff > k):``      ``j ``+``=` `1``      ``diff ``=` `a[i] ``-` `a[j]` `      ``ans ``=` `max``(ans, i``-``j``+``1``)` `      ``return` `n``-``ans` `    ``a ``=` `[``1``, ``3``, ``4``, ``9``, ``10``, ``11``, ``12``, ``17``, ``20``]``    ``n ``=` `len``(a)``    ``k ``=` `4` `    ``print``(removal(a, n, k))` `    ``# This code is contributed by lokeshmvs21.`

## C#

 `// C# program for the above approach` `using` `System;``using` `System.Collections;` `public` `class` `GFG {` `    ``static` `int` `removal(``int``[] a, ``int` `n, ``int` `k)``    ``{``        ``// Sort the Array``        ``Array.Sort(a);``        ``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, maintaining``        ``// two pointers for desired subarray which starting``        ``// from index j and ending with index i``        ``for` `(``int` `i = 0, j = 0; i < n; i++) {``            ``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 = Math.Max(ans, i - j + 1);``        ``}``        ``return` `n - ans;``    ``}` `    ``static` `public` `void` `Main()``    ``{` `        ``// Code``        ``int``[] a``            ``= ``new` `int``[] { 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 lokesh (lokeshmvs21).`

## Javascript

 `function` `removal(a, n, k)``  ``{` `    ``// Code here``    ``// Sort the Array; Time complexity:O(nlogn)``    ``a.sort();``    ``let diff = 0; ``// to store difference of max(a) and min(a)``    ``let ans = 0; ``// to store maximum length of array``    ``// with length <=k` `    ``// use sliding window to iterate array, maintaining``    ``// two pointers for desired subarray which starting``    ``// from index j and ending with index i``    ``for` `(let i = 0, j = 0; i < n; i++)``    ``{``      ``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 = Math.max(ans, i - j);``    ``}``    ``return` `n - ans;``  ``}` `  ``// Driver Code``    ``let a= [ 1, 3, 4, 9, 10, 11, 12, 17, 20 ];``    ``let n = a.length;``    ``let k = 4;``    ``document.write(removal(a, n, k));``  ` `  ``// This code is contributed by aadityaburujwale.```

Output

`5`

Time complexity: O(nlogn)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up