2091. Removing Minimum and Maximum From Array

class Solution {
    public int minimumDeletions(int[] nums) {
        int n = nums.length;
        
        // Find indices of min and max
        int minIdx = 0, maxIdx = 0;
        for (int i = 1; i < n; i++) {
            if (nums[i] < nums[minIdx]) minIdx = i;
            if (nums[i] > nums[maxIdx]) maxIdx = i;
        }
        
        // Make sure left <= right for convenience
        int left = Math.min(minIdx, maxIdx);
        int right = Math.max(minIdx, maxIdx);
        
        // Strategy 1: Both from front → remove up to right+1 elements
        int bothFront = right + 1;
        
        // Strategy 2: Both from back → remove from left to end
        int bothBack = n - left;
        
        // Strategy 3: left from front, right from back
        int splitWay = (left + 1) + (n - right);
        
        return Math.min(bothFront, Math.min(bothBack, splitWay));
    }
}

class Solution:
    def minimumDeletions(self, nums):
        n = len(nums)

        # Find indices of minimum and maximum
        min_idx = 0
        max_idx = 0

        for i in range(1, n):
            if nums[i] < nums[min_idx]:
                min_idx = i

            if nums[i] > nums[max_idx]:
                max_idx = i

        left = min(min_idx, max_idx)
        right = max(min_idx, max_idx)

        # Both from front
        both_front = right + 1

        # Both from back
        both_back = n - left

        # One from front and one from back
        split_way = (left + 1) + (n - right)

        return min(both_front, both_back, split_way)

class Solution {
public:
    int minimumDeletions(vector<int>& nums) {
        int n = nums.size();

        // Find indices of minimum and maximum
        int minIdx = 0;
        int maxIdx = 0;

        for (int i = 1; i < n; i++) {
            if (nums[i] < nums[minIdx]) {
                minIdx = i;
            }

            if (nums[i] > nums[maxIdx]) {
                maxIdx = i;
            }
        }

        int left = min(minIdx, maxIdx);
        int right = max(minIdx, maxIdx);

        // Both from front
        int bothFront = right + 1;

        // Both from back
        int bothBack = n - left;

        // One from front and one from back
        int splitWay = (left + 1) + (n - right);

        return min({
            bothFront,
            bothBack,
            splitWay
        });
    }
};

class Solution {
    minimumDeletions(nums) {
        const n = nums.length;

        // Find indices of minimum and maximum
        let minIdx = 0;
        let maxIdx = 0;

        for (let i = 1; i < n; i++) {
            if (nums[i] < nums[minIdx]) {
                minIdx = i;
            }

            if (nums[i] > nums[maxIdx]) {
                maxIdx = i;
            }
        }

        const left = Math.min(minIdx, maxIdx);
        const right = Math.max(minIdx, maxIdx);

        // Both from front
        const bothFront = right + 1;

        // Both from back
        const bothBack = n - left;

        // One from front and one from back
        const splitWay = (left + 1) + (n - right);

        return Math.min(
            bothFront,
            bothBack,
            splitWay
        );
    }
}