Removing Minimum and Maximum From Array solution and explanation

def minimum_deletions(nums):
    min_idx = nums.index(min(nums))
    max_idx = nums.index(max(nums))
    start, end = min(min_idx, max_idx), max(min_idx, max_idx)
    return min(end + 1, len(nums) - start, start + 1 + len(nums) - end)

print(minimum_deletions([2, 10, 7, 5, 4, 1, 8, 6]))
# Output: 5

import java.util.*;

public class MinMaxDeletion {
    public static int minimumDeletions(int[] nums) {
        int minIdx = 0, maxIdx = 0;
        for (int i = 1; i < nums.length; ++i) {
            if (nums[i] < nums[minIdx]) minIdx = i;
            if (nums[i] > nums[maxIdx]) maxIdx = i;
        }
        int start = Math.min(minIdx, maxIdx);
        int end = Math.max(minIdx, maxIdx);
        return Math.min(Math.min(end + 1, nums.length - start), start + 1 + nums.length - end);
    }

    public static void main(String[] args) {
        int[] nums = {2, 10, 7, 5, 4, 1, 8, 6};
        System.out.println(minimumDeletions(nums)); // Output: 5
    }
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int minimumDeletions(vector<int>& nums) {
    int minIdx = min_element(nums.begin(), nums.end()) - nums.begin();
    int maxIdx = max_element(nums.begin(), nums.end()) - nums.begin();
    int start = min(minIdx, maxIdx);
    int end = max(minIdx, maxIdx);

    return min({end + 1, (int)nums.size() - start, start + 1 + (int)nums.size() - end});
}

int main() {
    vector<int> nums = {2, 10, 7, 5, 4, 1, 8, 6};
    cout << minimumDeletions(nums) << endl; // Output: 5
    return 0;
}

function minimumDeletions(nums) {
    let minIdx = 0, maxIdx = 0;
    for (let i = 1; i < nums.length; ++i) {
        if (nums[i] < nums[minIdx]) minIdx = i;
        if (nums[i] > nums[maxIdx]) maxIdx = i;
    }
    const start = Math.min(minIdx, maxIdx);
    const end = Math.max(minIdx, maxIdx);
    return Math.min(end + 1, nums.length - start, start + 1 + nums.length - end);
}

console.log(minimumDeletions([2, 10, 7, 5, 4, 1, 8, 6]));
// Output: 5

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

int minimumDeletions(int* nums, int numsSize) {
    int minIdx = 0, maxIdx = 0;
    for (int i = 1; i < numsSize; ++i) {
        if (nums[i] < nums[minIdx]) minIdx = i;
        if (nums[i] > nums[maxIdx]) maxIdx = i;
    }

    int start = fmin(minIdx, maxIdx);
    int end = fmax(minIdx, maxIdx);

    // Three strategies
    return fmin(fmin(end + 1, numsSize - start), start + 1 + numsSize - end); 
}

int main() {
    int nums[] = {2, 10, 7, 5, 4, 1, 8, 6};
    int size = sizeof(nums) / sizeof(nums[0]);
    printf("%d\n", minimumDeletions(nums, size)); // Output: 5
    return 0;
}

using System;

public class Solution {
    public int MinimumDeletions(int[] nums) {
        int minIdx = 0, maxIdx = 0;
        for (int i = 1; i < nums.Length; i++) {
            if (nums[i] < nums[minIdx]) minIdx = i;
            if (nums[i] > nums[maxIdx]) maxIdx = i;
        }
        int start = Math.Min(minIdx, maxIdx);
        int end = Math.Max(minIdx, maxIdx);
        return Math.Min(Math.Min(end + 1, nums.Length - start), start + 1 + nums.Length - end);
    }

    public static void Main() {
        int[] nums = {2, 10, 7, 5, 4, 1, 8, 6};
        Console.WriteLine(new Solution().MinimumDeletions(nums)); // Output: 5
    }
}

#include <iostream>
#include <vector>
#include <limits>
#include <algorithm>
using namespace std;

int minimumDeletions(vector<int>& nums) {
    int minIdx = 0, maxIdx = 0, n = nums.size();
    for (int i = 1; i < n; i++) {
        if (nums[i] < nums[minIdx]) minIdx = i;
        if (nums[i] > nums[maxIdx]) maxIdx = i;
    }
    
    int leftRemovals = max(minIdx, maxIdx) + 1;
    int rightRemovals = n - min(minIdx, maxIdx);
    int crossRemovals = minIdx + 1 + n - maxIdx > maxIdx + 1 + n - minIdx ? maxIdx + 1 + n - minIdx : minIdx + 1 + n - maxIdx;
    
    return min({leftRemovals, rightRemovals, crossRemovals});
}

int main() {
    vector<int> nums = {2, 10, 7, 5, 4, 1, 8, 6};
    cout << minimumDeletions(nums) << endl; // Output: 5
    return 0;
}

#include <stdio.h>

int minimumDeletions(int* nums, int numsSize) {
    int minIdx = 0, maxIdx = 0;
    int n = numsSize;

    for (int i = 1; i < numsSize; ++i) {
        if (nums[i] < nums[minIdx]) minIdx = i;
        if (nums[i] > nums[maxIdx]) maxIdx = i;
    }
    
    int leftRemovals = (maxIdx > minIdx) ? maxIdx + 1 : minIdx + 1;
    int rightRemovals = (n - minIdx > n - maxIdx) ? n - minIdx : n - maxIdx;
    int mixedRemovals = (minIdx + 1) + (n - maxIdx > maxIdx ? n - maxIdx : n - minIdx);
    
    return leftRemovals <= rightRemovals && leftRemovals <= mixedRemovals ? leftRemovals : rightRemovals <= mixedRemovals ? rightRemovals : mixedRemovals;
}

int main() {
    int nums[] = {2, 10, 7, 5, 4, 1, 8, 6};
    printf("%d\n", minimumDeletions(nums, 8)); // Output: 5
    return 0;
}

function minimumDeletions(nums: number[]): number {
    const n = nums.length;
    if (n == 1) return 1;
    let i = nums.indexOf(Math.min(...nums));
    let j = nums.indexOf(Math.max(...nums));
    let left = Math.min(i, j);
    let right = Math.max(i, j);
    // 左右 left + 1 + n - right
    // 两个都是左边 left + 1 + right - left = right + 1
    // 都是右边 n - right + right - left = n - left
    return Math.min(left + 1 + n - right, right + 1, n - left);
}

func minimumDeletions(nums []int) int {
	mi, mx, n := 0, 0, len(nums)
	for i, num := range nums {
		if num < nums[mi] {
			mi = i
		}
		if num > nums[mx] {
			mx = i
		}
	}
	if mi > mx {
		mi, mx = mx, mi
	}
	return min(min(mx+1, n-mi), mi+1+n-mx)
}