 Open in App
Not now

# Minimize deletions from either end to remove Minimum and Maximum from Array

• Last Updated : 29 Jun, 2022

Given array of integers arr[] of size N, the task is to find the count of minimum number of deletion operations to remove minimum and the maximum element from the array. The elements can only be deleted from either end of the array.

Examples:

Input: arr = [2, 10, 7, 5, 4, 1, 8, 6]
Output: 5
Explanation: The minimum element is 1 and the maximum element is 10. We can visualise the deletion operations as below:
[2, 10, 7, 5, 4, 1, 8, 6]
[2, 10, 7, 5, 4, 1, 8]
[2, 10, 7, 5, 4, 1]
[2, 10, 7, 5, 4]
[10, 7, 5, 4]
[7, 5, 4]

Total 5 deletion operations performed. There is no other sequence with less deletions in which the minimum and maximum can be deleted.

Input: arr = 
Output: 1
Explanation: Because the array only has one entry, it serves as both the lowest and maximum value. With a single delete, we can eliminate it.

Input: arr = [2, 5, 8, 3, 6, 4]
Output: 3
Explanation: The minimum element is 2 and the maximum element is 8. We can visualise the deletion operations as below:
[2, 5, 8, 3, 6, 4]
[5, 8, 3, 6, 4]
[8, 3, 6, 4]
[3, 6, 4]

Total 3 deletions are performed. It is the minimum possible number of deletions.

Approach: The above problem can be solved using below observation:

Suppose the max and min elements exists at index i and j, or vice versa, as shown below:

```[ _ _ _ _ _ min/max _ _ _ _ _ _ max/min _ _ _ _ _ _ ]
<-- a -->   (i)   <---  b --->  (j)  <---- c ---->
<-----------------------N ------------------------->```

where,

• i, j: index of either max or min element of the array
• a: distance of the minimum (or maximum) element from starting
• b: distance between minimum and maximum element
• c: distance between maximum( or minimum) element from ending
• N: length of array

Now let’s look at different possible ways of deletion:

• For removing one from start and the other from end:

No. of deletion = (a + c) = ( (i + 1) + (n – j) )

• For removing both of them from starting of the array:

No. of deletion = (a + b) = (j + 1)

• For removing both of them from the end of the array:

No. of deletion = (b + c) = (n – i)

Using the above equations we can now easily get distances using the index of min and max element. The answer is minimum of these 3 cases

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the above approach`   `#include ` `using` `namespace` `std;`   `// Function to return` `// the minimum number of deletions` `int` `minDeletions(vector<``int``>& nums)` `{` `    ``int` `n = nums.size();`   `    ``// Index of minimum element` `    ``int` `minindex ` `      ``= min_element(nums.begin(), nums.end())` `                   ``- nums.begin();`   `    ``// Index of maximum element` `    ``int` `maxindex ` `      ``= max_element(nums.begin(), nums.end())` `                   ``- nums.begin();`   `    ``// Assume that minimum element` `    ``// always occur before maximum element.` `    ``// If not, then swap its index.` `    ``if` `(minindex > maxindex)` `        ``swap(minindex, maxindex);`   `    ``// Deletion operations for case-1` `    ``int` `bothend = (minindex + 1) + ` `      ``(n - maxindex);`   `    ``// Deletion operations for case-2` `    ``int` `frontend = (maxindex + 1);`   `    ``// Deletion operations for case-3` `    ``int` `backend = (n - minindex);`   `    ``// Least number of deletions is the answer` `    ``int` `ans = min(bothend, ` `                  ``min(frontend, backend));`   `    ``return` `ans;` `}`   `// Driver code` `int` `main()` `{` `    ``vector<``int``> arr{ 2, 10, 7, 5, 4, 1, 8, 6 };` `    ``cout << minDeletions(arr) << endl;`   `    ``vector<``int``> arr2{ 56 };` `    ``cout << minDeletions(arr2);`   `    ``return` `0;` `}`

## Java

 `// Java code to implement the above approach` `import` `java.util.Arrays;` `import` `java.util.stream.IntStream;`   `class` `GFG{`   `// Function to return the ` `// minimum number of deletions` `int` `minDeletions(``int``[] nums)` `{` `    ``int` `n = nums.length;` `    `  `    ``// Index of minimum element` `    ``int` `minindex = findIndex(nums,` `    ``Arrays.stream(nums).min().getAsInt());`   `    ``// Index of maximum element` `    ``int` `maxindex = findIndex(` `        ``nums, Arrays.stream(nums).max().getAsInt());`   `    ``// Assume that minimum element` `    ``// always occur before maximum element.` `    ``// If not, then swap its index.` `    ``if` `(minindex > maxindex)` `    ``{` `        ``minindex = minindex + maxindex;` `        ``maxindex = minindex - maxindex;` `        ``minindex = minindex - maxindex;` `    ``}`   `    ``// Deletion operations for case-1` `    ``int` `bothend = (minindex + ``1``) + (n - maxindex);`   `    ``// Deletion operations for case-2` `    ``int` `frontend = (maxindex + ``1``);`   `    ``// Deletion operations for case-3` `    ``int` `backend = (n - minindex);`   `    ``// Least number of deletions is the answer` `    ``int` `ans = Math.min(` `        ``bothend, Math.min(frontend, backend));`   `    ``return` `ans;` `}`   `// Function to find the index of an element` `public` `static` `int` `findIndex(``int` `arr[], ``int` `t)` `{` `    ``int` `len = arr.length;` `    ``return` `IntStream.range(``0``, len)` `        ``.filter(i -> t == arr[i])` `        ``.findFirst() ``// first occurrence` `        ``.orElse(-``1``); ``// No element found` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``int``[] arr = { ``2``, ``10``, ``7``, ``5``, ``4``, ``1``, ``8``, ``6` `};` `    ``System.out.print(``new` `GFG().minDeletions(arr) + ``"\n"``);`   `    ``int` `[]arr2 = { ``56` `};` `    ``System.out.print(``new` `GFG().minDeletions(arr2));` `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python 3 code to implement the above approach`   `# Function to return` `# the minimum number of deletions` `def` `minDeletions(nums):`   `    ``n ``=` `len``(nums)`   `    ``# Index of minimum element` `    ``minindex ``=` `nums.index(``min``(nums))`   `    ``# Index of maximum element` `    ``maxindex ``=` `nums.index(``max``(nums))`   `    ``# Assume that minimum element` `    ``# always occur before maximum element.` `    ``# If not, then swap its index.` `    ``if` `(minindex > maxindex):` `        ``minindex, maxindex ``=` `maxindex, minindex`   `    ``# Deletion operations for case-1` `    ``bothend ``=` `(minindex ``+` `1``) ``+` `(n ``-` `maxindex)`   `    ``# Deletion operations for case-2` `    ``frontend ``=` `(maxindex ``+` `1``)`   `    ``# Deletion operations for case-3` `    ``backend ``=` `(n ``-` `minindex)`   `    ``# Least number of deletions is the answer` `    ``ans ``=` `min``(bothend,` `              ``min``(frontend, backend))`   `    ``return` `ans`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``arr ``=` `[``2``, ``10``, ``7``, ``5``, ``4``, ``1``, ``8``, ``6``]` `    ``print``(minDeletions(arr))`   `    ``arr2 ``=` `[``56``]` `    ``print``(minDeletions(arr2))`   `    ``# This code is contributed by ukasp.`

## C#

 `// C# code to implement the above approach` `using` `System;` `using` `System.Linq;`   `public` `class` `GFG{`   `// Function to return the ` `// minimum number of deletions` `int` `minDeletions(``int``[] nums)` `{` `    ``int` `n = nums.Length;` `    `  `    ``// Index of minimum element` `    ``int` `minindex = findIndex(nums,` `    ``nums.Min());`   `    ``// Index of maximum element` `    ``int` `maxindex = findIndex(` `        ``nums, nums.Max());`   `    ``// Assume that minimum element` `    ``// always occur before maximum element.` `    ``// If not, then swap its index.` `    ``if` `(minindex > maxindex)` `    ``{` `        ``minindex = minindex + maxindex;` `        ``maxindex = minindex - maxindex;` `        ``minindex = minindex - maxindex;` `    ``}`   `    ``// Deletion operations for case-1` `    ``int` `bothend = (minindex + 1) + (n - maxindex);`   `    ``// Deletion operations for case-2` `    ``int` `frontend = (maxindex + 1);`   `    ``// Deletion operations for case-3` `    ``int` `backend = (n - minindex);`   `    ``// Least number of deletions is the answer` `    ``int` `ans = Math.Min(` `        ``bothend, Math.Min(frontend, backend));`   `    ``return` `ans;` `}`   `// Function to find the index of an element` `public` `static` `int` `findIndex(``int` `[]arr, ``int` `t)` `{` `    ``int` `len = arr.Length;` `    ``return`  `Array.IndexOf(arr, t);` `}`   `// Driver code` `public` `static` `void` `Main(String[] args)` `{` `    ``int``[] arr = { 2, 10, 7, 5, 4, 1, 8, 6 };` `    ``Console.Write(``new` `GFG().minDeletions(arr) + ``"\n"``);`   `    ``int` `[]arr2 = { 56 };` `    ``Console.Write(``new` `GFG().minDeletions(arr2));` `}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

```5
1```

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles