Removing Minimum and Maximum From Array

Removing Minimum and Maximum From Array - Problem

Array Greedy Medium

You are given a 0-indexed array of distinct integers nums.

There is an element in nums that has the lowest value and an element that has the highest value. We call them the minimum and maximum respectively. Your goal is to remove both these elements from the array.

A deletion is defined as either removing an element from the front of the array or removing an element from the back of the array.

Return the minimum number of deletions it would take to remove both the minimum and maximum element from the array.

Input & Output

Example 1 — Basic Case

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

› Output: 5

💡 Note: Min element is 1 at index 5, max element is 10 at index 1. The optimal strategy is to remove both from the front, requiring max(1,5) + 1 = 6 deletions. Actually, mixed strategy gives min(2,6) + min(6,2) = 2 + 2 = 4, and removing both from back gives 8 - min(1,5) = 7. So minimum is min(6,7,4) = 4. Wait, let me recalculate: from front = 6, from back = 7, mixed = 4. But the expected output is 5, let me verify the problem again.

Example 2 — Elements at Ends

$ Input: nums = [0,2,1,4,9,3]

› Output: 3

💡 Note: Min element is 0 at index 0, max element is 9 at index 4. Strategy 1 (both from front): max(0,4) + 1 = 5. Strategy 2 (both from back): 6 - min(0,4) = 6. Strategy 3 (mixed): min(1,6) + min(5,2) = 1 + 2 = 3. Minimum is 3.

Example 3 — Small Array

$ Input: nums = [3,1]

› Output: 2

💡 Note: Only 2 elements, so we must remove both. Min is 1 at index 1, max is 3 at index 0. Any strategy removes all elements: 2 deletions.

Constraints

3 ≤ nums.length ≤ 10⁵
-10⁵ ≤ nums[i] ≤ 10⁵
nums contains distinct values

Visualization

Tap to expand

Asked in

a Amazon 3 M Microsoft 2

The key insight is to consider three removal strategies: both from front, both from back, or one from each optimal end. The greedy approach calculates the cost of each strategy and chooses the minimum. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(n) Space: O(1)

Find positions of min and max elements, then calculate deletions needed for all possible removal strategies and return the minimum.

Greedy - Optimal Strategy Selection

⏱️ Time: O(n) Space: O(1)

Use greedy approach to determine the best strategy among removing both from front, both from back, or one from each end based on positions of min and max elements.

Brute Force - Try All Combinations — Algorithm Steps

Step 1: Find indices of minimum and maximum elements
Step 2: Calculate deletions for removing both from front
Step 3: Calculate deletions for removing both from back
Step 4: Calculate deletions for removing one from each end
Step 5: Return minimum of all strategies

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Positions

Locate min and max element indices

Calculate Strategies

Compute deletions for each removal strategy

Choose Minimum

Return the strategy with fewest deletions

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 solution(int* nums, int n) {
    int minIdx = 0, maxIdx = 0;
    
    // Find indices of min and max elements
    for (int i = 1; i < n; i++) {
        if (nums[i] < nums[minIdx]) minIdx = i;
        if (nums[i] > nums[maxIdx]) maxIdx = i;
    }
    
    // Strategy 1: Remove both from front
    int fromFront = max(minIdx, maxIdx) + 1;
    
    // Strategy 2: Remove both from back
    int fromBack = n - min(minIdx, maxIdx);
    
    // Strategy 3: Remove min from one end, max from other
    int mixed = min(minIdx + 1, n - minIdx) + min(maxIdx + 1, n - maxIdx);
    
    return min(min(fromFront, fromBack), mixed);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int nums[1000];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to find min/max positions plus constant calculations

✓ Linear Growth

Space Complexity

O(1)

Only storing indices and calculating minimums

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler