Removing Minimum and Maximum From Array - Practice Coding Problems

Removing Minimum and Maximum From Array - Problem

Array Greedy Medium

Array Cleanup Challenge: You're given a 0-indexed array of distinct integers. Your mission is to remove both the minimum and maximum elements from the array using the fewest possible deletions.

🔹 Deletion Rules: You can only remove elements from the front or back of the array
🔹 Goal: Find the minimum number of deletions needed to eliminate both extremes

Think of it as trimming a line of people where you can only remove from either end, and you need to eliminate both the shortest and tallest person with minimum moves!

Input & Output

example_1.py — Basic Case

$ Input: [2, 10, 7, 5, 4, 1, 8, 6]

› Output: 5

💡 Note: Minimum is 1 (index 5), Maximum is 10 (index 1). Best strategy is to remove from right: 8 - 1 = 7, but mixed approach gives us min(6+3, 2+3) = 5 deletions.

example_2.py — Edge Case

$ Input: [0, -4, 19, 1, 4]

› Output: 3

💡 Note: Minimum is -4 (index 1), Maximum is 19 (index 2). Left-only strategy: max(1,2)+1 = 3. Right-only: 5-min(1,2) = 4. Mixed: min(2+3, 3+4) = 5. Optimal is 3.

example_3.py — Small Array

$ Input: [101]

› Output: 1

💡 Note: Array has only one element, which is both minimum and maximum. We need 1 deletion to remove it.

Constraints

3 ≤ nums.length ≤ 10⁵
-10⁵ ≤ nums[i] ≤ 10⁵
All integers in nums are distinct
Array is 0-indexed

Visualization

Tap to expand

Understanding the Visualization

Identify Targets

Find the positions of the thinnest (minimum) and thickest (maximum) books on the shelf

Strategy 1 - Left Side

Calculate cost of removing books from the left until both target books are gone

Strategy 2 - Right Side

Calculate cost of removing books from the right until both targets are eliminated

Strategy 3 - Mixed Approach

Remove books from left to get one target, from right to get the other target

Choose Optimal

Select the strategy with minimum total removals

Key Takeaway

🎯 Key Insight: Only three strategies exist for optimal removal - the greedy approach calculates all three costs and picks the minimum, achieving O(n) efficiency.

Asked in

a Amazon 45 ⊞ Microsoft 35 G Google 28 f Meta 22

The optimal greedy approach recognizes that there are only 3 strategic ways to remove both minimum and maximum elements: remove from left only, remove from right only, or use a mixed approach (remove one extreme from each end). Calculate all three costs and return the minimum in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Optimal Strategy	O(n)	O(1)	Calculate three strategies and pick the minimum: left-only, right-only, or mixed approach
Brute Force (Try All Combinations)	O(n²)	O(1)	Try all possible combinations of left and right deletions

Greedy Optimal Strategy — Algorithm Steps

Find positions of minimum and maximum elements
Calculate cost of removing from left until both are eliminated
Calculate cost of removing from right until both are eliminated
Calculate cost of mixed approach (left to one, right to other)
Return the minimum of these three strategies

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Positions

Locate minimum at index 0 and maximum at index 2

Left Strategy

Remove from left until both extremes are gone: max(0,2)+1 = 3

Right Strategy

Remove from right until both extremes are gone: 5-min(0,2) = 5

Mixed Strategy

Remove min from left, max from right: min(1+2, 3+3) = 3

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int min(int a, int b) {
    return a < b ? a : b;
}

int max(int a, int b) {
    return a > b ? a : b;
}

int minimumDeletions(int* nums, int numsSize) {
    if (numsSize <= 2) return numsSize;
    
    int minVal = nums[0], maxVal = nums[0];
    int minIdx = 0, maxIdx = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < minVal) {
            minVal = nums[i];
            minIdx = i;
        }
        if (nums[i] > maxVal) {
            maxVal = nums[i];
            maxIdx = i;
        }
    }
    
    // Strategy 1: Remove from left until both are gone
    int leftOnly = max(minIdx, maxIdx) + 1;
    
    // Strategy 2: Remove from right until both are gone
    int rightOnly = numsSize - min(minIdx, maxIdx);
    
    // Strategy 3: Remove from left for one, right for other
    int mixed = min(
        minIdx + 1 + numsSize - maxIdx,
        maxIdx + 1 + numsSize - minIdx
    );
    
    return min(min(leftOnly, rightOnly), mixed);
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[1000];
    int count = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", minimumDeletions(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to find min/max positions, then constant time calculations

✓ Linear Growth

Space Complexity

O(1)

Only storing positions and calculating three strategy costs

✓ Linear Space

42.8K Views

Medium Frequency

~18 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy Optimal Strategy — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler