 Open in App
Not now

# Minimum deletions from front or back required to remove maximum and minimum from Array

• Difficulty Level : Hard
• Last Updated : 26 Oct, 2021

Given an array arr[] consisting of integers. The task is to find minimum deletions required to remove the initial minimum and maximum element from arr[].
NOTE: Deletion can be performed either from the front or back of the array.

Examples:

Input: arr[] = {5, 7, 2, 4, 3}
Output: 3
Explanation: Initial minimum = 2, Initial maximum = 7
Deleting first 3 from arr[] updates arr[] to {2, 4, 3} which is free from Initial maximum and minimum elements.
Therefore 3 operations are required which is minimum possible.

Input: arr[] = {2, -1, 3, 5, 8, -7}
Output: 2

Approach: The given problem can be solved by using Greedy Approach. Follow the steps below to solve the given problem.

• Initialize two variables say mn, mx to store minimum and maximum elements respectively.
• Use two variables say minIndex, maxIndex to store the last occurrence of minimum and maximum elements.
• Iterate arr[] with i
• update mn = min(mn, arr[i])
• update mx = max(mx, arr[i])
• Use two variables say minIndex, maxIndex to store the last occurrence of minimum and maximum elements.
• Iterate arr[] with i
• if arr[i] = mn, then update minIndex = i
• if arr[i] = mx, then update maxIndex = i
• Calculate all the cases of deletion and store in variables x, y, z.
• Return minimum among x, y, z as the final answer.

Below is the implementation of the above approach.

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to calculate minimum deletions to ` `// remove initial minimum and maximum` `int` `minDeletions(``int` `*arr, ``int` `N)` `{` `    ``// To store initial minimum and maximum` `    ``int` `mn = INT_MAX, mx = INT_MIN;`   `    ``// Iterate and find min and max in arr[]` `    ``for``(``int` `i = 0; i < N; i++) {` `        ``mn = min(mn, arr[i]);` `        ``mx = max(mx, arr[i]);` `    ``}`   `    ``// To store indices of last min and max` `    ``int` `minIndex, maxIndex;` `    ``for``(``int` `i = 0; i < N; i++) {` `        ``if``(arr[i] == mn) minIndex = i;` `        ``if``(arr[i] == mx) maxIndex = i;` `    ``}`     `    ``int` `temp = max(minIndex, maxIndex);` `    ``minIndex = min(minIndex, maxIndex);` `    ``maxIndex = temp;`   `    ``// Calculating all possible case of ` `    ``// deletion operations` `    ``int` `x = N - maxIndex + minIndex + 1;` `    ``int` `y = N - minIndex;` `    ``int` `z = maxIndex + 1;`   `    ``// Return minimum among all the three cases` `    ``return` `min({x, y, z});` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 6;` `    ``int` `arr[] = {2, -1, 9, 7, -2, 3};`   `    ``cout << minDeletions(arr, N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `import` `java.util.*;` `class` `GFG ` `{` `  `  `    ``// Function to calculate minimum deletions to` `    ``// remove initial minimum and maximum` `    ``static` `int` `minDeletions(``int` `arr[], ``int` `N)` `    ``{` `      `  `        ``// To store initial minimum and maximum` `        ``int` `mn = Integer.MAX_VALUE, mx = Integer.MIN_VALUE;`   `        ``// Iterate and find min and max in arr[]` `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``mn = Math.min(mn, arr[i]);` `            ``mx = Math.max(mx, arr[i]);` `        ``}`   `        ``// To store indices of last min and max` `        ``int` `minIndx = ``0``, maxIndx = ``0``;` `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``if` `(arr[i] == mn)` `                ``minIndx = i;` `            ``if` `(arr[i] == mx)` `                ``maxIndx = i;` `        ``}`   `        ``int` `temp = Math.max(minIndx, maxIndx);` `        ``minIndx = Math.min(minIndx, maxIndx);` `        ``maxIndx = temp;`   `        ``// Calculating all possible case of` `        ``// deletion operations` `        ``int` `x = N - maxIndx + minIndx + ``1``;` `        ``int` `y = N - minIndx;` `        ``int` `z = maxIndx + ``1``;`   `        ``// Return minimum among all the three cases` `        ``return` `Math.min(x, Math.min(y, z));` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = { ``2``, -``1``, ``9``, ``7``, -``2``, ``3` `};` `        ``int` `N = ``6``;` `        ``System.out.println(minDeletions(arr, N));` `    ``}` `}`   `// This code is contributed by dwivediyash`

## Python3

 `# python program for the above approach` `INT_MIN ``=` `-``2147483648` `INT_MAX ``=` `2147483647`   `# Function to calculate minimum deletions to` `# remove initial minimum and maximum` `def` `minDeletions(arr, N):`   `        ``# To store initial minimum and maximum` `    ``mn ``=` `INT_MAX` `    ``mx ``=` `INT_MIN`   `    ``# Iterate and find min and max in arr[]` `    ``for` `i ``in` `range``(``0``, N):` `        ``mn ``=` `min``(mn, arr[i])` `        ``mx ``=` `max``(mx, arr[i])`   `        ``# To store indices of last min and max` `    ``minIndex ``=` `0` `    ``maxIndex ``=` `0` `    ``for` `i ``in` `range``(``0``, N):` `        ``if``(arr[i] ``=``=` `mn):` `            ``minIndex ``=` `i` `        ``if``(arr[i] ``=``=` `mx):` `            ``maxIndex ``=` `i`   `    ``temp ``=` `max``(minIndex, maxIndex)` `    ``minIndex ``=` `min``(minIndex, maxIndex)` `    ``maxIndex ``=` `temp`   `    ``# Calculating all possible case of` `    ``# deletion operations` `    ``x ``=` `N ``-` `maxIndex ``+` `minIndex ``+` `1` `    ``y ``=` `N ``-` `minIndex` `    ``z ``=` `maxIndex ``+` `1`   `    ``# Return minimum among all the three cases` `    ``return` `min``({x, y, z})`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``N ``=` `6` `    ``arr ``=` `[``2``, ``-``1``, ``9``, ``7``, ``-``2``, ``3``]`   `    ``print``(minDeletions(arr, N))`   `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# program for the above approach` `using` `System;` `class` `GFG ` `{` `  `  `    ``// Function to calculate minimum deletions to` `    ``// remove initial minimum and maximum` `    ``static` `int` `minDeletions(``int``[] arr, ``int` `N)` `    ``{` `      `  `        ``// To store initial minimum and maximum` `        ``int` `mn = ``int``.MaxValue, mx = ``int``.MinValue;`   `        ``// Iterate and find min and max in arr[]` `        ``for` `(``int` `i = 0; i < N; i++) {` `            ``mn = Math.Min(mn, arr[i]);` `            ``mx = Math.Max(mx, arr[i]);` `        ``}`   `        ``// To store indices of last min and max` `        ``int` `minIndx = 0, maxIndx = 0;` `        ``for` `(``int` `i = 0; i < N; i++) {` `            ``if` `(arr[i] == mn)` `                ``minIndx = i;` `            ``if` `(arr[i] == mx)` `                ``maxIndx = i;` `        ``}`   `        ``int` `temp = Math.Max(minIndx, maxIndx);` `        ``minIndx = Math.Min(minIndx, maxIndx);` `        ``maxIndx = temp;`   `        ``// Calculating all possible case of` `        ``// deletion operations` `        ``int` `x = N - maxIndx + minIndx + 1;` `        ``int` `y = N - minIndx;` `        ``int` `z = maxIndx + 1;`   `        ``// Return minimum among all the three cases` `        ``return` `Math.Min(x, Math.Min(y, z));` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] arr = { 2, -1, 9, 7, -2, 3 };` `        ``int` `N = 6;` `        ``Console.Write(minDeletions(arr, N));` `    ``}` `}`   `// This code is contributed by gfgking`

## Javascript

 ``

Output

`4`

Time Complexity: O(N)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles