Closest MinMax

1 <= |A| <= 2000

First and only argument is vector A

Return the length of the smallest subarray which has at least one occurrence of minimum and maximum element of the array

Input 1:
A = [1, 3, 2]

Input 2:
A = [2, 6, 1, 6, 9]

Output 1:
2

Output 2:
3

Explanation 1:
Take the 1st and 2nd elements as they are the minimum and maximum elements respectievly.

Explanation 2:
Take the last 3 elements of the array.

import java.util.*;
 
public class ClosestMinMax {
    public static int closestMinMaxSize(ArrayList<Integer> A) {
        int n = A.size();
        int minIndex = -1, maxIndex = -1;
        int minMaxSize = Integer.MAX_VALUE;
 
        int min = Collections.min(A);
        int max = Collections.max(A);
 
        for (int i = 0; i < n; i++) {
            if (A.get(i) == min) {
                minIndex = i;
            }
            if (A.get(i) == max) {
                maxIndex = i;
            }
            if (minIndex != -1 && maxIndex != -1) {
                minMaxSize = Math.min(minMaxSize, Math.abs(maxIndex - minIndex) + 1);
            }
        }
        return minMaxSize;
    }
 
    public static void main(String[] args) {
        ArrayList<Integer> A1 = new ArrayList<>(Arrays.asList(1, 3, 2));
        ArrayList<Integer> A2 = new ArrayList<>(Arrays.asList(2, 6, 1, 6, 9));
 
        System.out.println("Output 1: " + closestMinMaxSize(A1));
        System.out.println("Output 2: " + closestMinMaxSize(A2));
    }
}

def closest_min_max_size(A):
    min_index = -1
    max_index = -1
    min_max_size = float('inf')
 
    minimum = min(A)
    maximum = max(A)
 
    for i in range(len(A)):
        if A[i] == minimum:
            min_index = i
        if A[i] == maximum:
            max_index = i
        if min_index != -1 and max_index != -1:
            min_max_size = min(min_max_size, abs(max_index - min_index) + 1)
 
    return min_max_size
 
A1 = [1, 3, 2]
A2 = [2, 6, 1, 6, 9]
 
print("Output 1:", closest_min_max_size(A1))
print("Output 2:", closest_min_max_size(A2))

function closestMinMaxSize(A) {
    let minIndex = -1;
    let maxIndex = -1;
    let minMaxSize = Infinity;
 
    const min = Math.min(...A);
    const max = Math.max(...A);
 
    A.forEach((value, index) => {
        if (value === min) {
            minIndex = index;
        }
        if (value === max) {
            maxIndex = index;
        }
        if (minIndex !== -1 && maxIndex !== -1) {
            minMaxSize = Math.min(minMaxSize, Math.abs(maxIndex - minIndex) + 1);
        }
    });
 
    return minMaxSize;
}
 
const A1 = [1, 3, 2];
const A2 = [2, 6, 1, 6, 9];
 
console.log("Output 1:", closestMinMaxSize(A1));
console.log("Output 2:", closestMinMaxSize(A2));