Minimum covering window.

def min_cover(values, required):
    # [1] Count what is required; the empty window lacks every copy.
    need = {}
    for value in required:
        need[value] = need.get(value, 0) + 1
    missing = len(required)
    window = {}
    left = 0
    best_start = -1
    best_end = -1
    for right in range(len(values)):
        # [2] The value at right joins; missing drops only while its count is at or below its need.
        joining = values[right]
        window[joining] = window.get(joining, 0) + 1
        if window[joining] <= need.get(joining, 0):
            missing -= 1  # it fills a gap; a surplus copy fills none
        # [3] While the window covers, record it if shorter, then the value at left leaves.
        while missing == 0:
            if best_start == -1 or right - left < best_end - best_start:
                best_start = left  # strictly shorter only, so the earliest of equal windows stays
                best_end = right
            leaving = values[left]
            window[leaving] -= 1
            if window[leaving] < need.get(leaving, 0):
                missing += 1  # the window now lacks a copy it needs
            left += 1
    # [4] Report the shortest covering window, or [-1, -1] if none covers.
    return [best_start, best_end]

public int[] minCover(int[] values, int[] required) {
    // [1] Count what is required; the empty window lacks every copy.
    Map<Integer, Integer> need = new HashMap<>();
    for (int value : required) {
        need.put(value, need.getOrDefault(value, 0) + 1);
    }
    int missing = required.length;
    Map<Integer, Integer> window = new HashMap<>();
    int left = 0;
    int bestStart = -1;
    int bestEnd = -1;
    for (int right = 0; right < values.length; right++) {
        // [2] The value at right joins; missing drops only while its count is at or below its need.
        int joining = values[right];
        int count = window.getOrDefault(joining, 0) + 1;
        window.put(joining, count);
        if (count <= need.getOrDefault(joining, 0)) {
            missing--;  // it fills a gap; a surplus copy fills none
        }
        // [3] While the window covers, record it if shorter, then the value at left leaves.
        while (missing == 0) {
            if (bestStart == -1 || right - left < bestEnd - bestStart) {
                bestStart = left;  // strictly shorter only, so the earliest of equal windows stays
                bestEnd = right;
            }
            int leaving = values[left];
            int remaining = window.get(leaving) - 1;
            window.put(leaving, remaining);
            if (remaining < need.getOrDefault(leaving, 0)) {
                missing++;  // the window now lacks a copy it needs
            }
            left++;
        }
    }
    // [4] Report the shortest covering window, or [-1, -1] if none covers.
    return new int[] {bestStart, bestEnd};
}

vector<int> minCover(const vector<int>& values, const vector<int>& required) {
    // [1] Count what is required; the empty window lacks every copy.
    unordered_map<int, int> need;
    for (int value : required) {
        need[value]++;
    }
    int missing = required.size();
    unordered_map<int, int> window;
    int left = 0;
    int bestStart = -1;
    int bestEnd = -1;
    for (int right = 0; right < (int) values.size(); right++) {
        // [2] The value at right joins; missing drops only while its count is at or below its need.
        int joining = values[right];
        int count = ++window[joining];
        auto found = need.find(joining);
        if (found != need.end() && count <= found->second) {
            missing--;  // it fills a gap; a surplus copy fills none
        }
        // [3] While the window covers, record it if shorter, then the value at left leaves.
        while (missing == 0) {
            if (bestStart == -1 || right - left < bestEnd - bestStart) {
                bestStart = left;  // strictly shorter only, so the earliest of equal windows stays
                bestEnd = right;
            }
            int leaving = values[left];
            int remaining = --window[leaving];
            auto needed = need.find(leaving);
            if (needed != need.end() && remaining < needed->second) {
                missing++;  // the window now lacks a copy it needs
            }
            left++;
        }
    }
    // [4] Report the shortest covering window, or [-1, -1] if none covers.
    return {bestStart, bestEnd};
}

function minCover(values, required) {
  // [1] Count what is required; the empty window lacks every copy.
  const need = new Map();
  for (const value of required) {
    need.set(value, (need.get(value) || 0) + 1);
  }
  let missing = required.length;
  const window = new Map();
  let left = 0;
  let bestStart = -1;
  let bestEnd = -1;
  for (let right = 0; right < values.length; right++) {
    // [2] The value at right joins; missing drops only while its count is at or below its need.
    const joining = values[right];
    const count = (window.get(joining) || 0) + 1;
    window.set(joining, count);
    if (count <= (need.get(joining) || 0)) {
      missing--;  // it fills a gap; a surplus copy fills none
    }
    // [3] While the window covers, record it if shorter, then the value at left leaves.
    while (missing === 0) {
      if (bestStart === -1 || right - left < bestEnd - bestStart) {
        bestStart = left;  // strictly shorter only, so the earliest of equal windows stays
        bestEnd = right;
      }
      const leaving = values[left];
      const remaining = window.get(leaving) - 1;
      window.set(leaving, remaining);
      if (remaining < (need.get(leaving) || 0)) {
        missing++;  // the window now lacks a copy it needs
      }
      left++;
    }
  }
  // [4] Report the shortest covering window, or [-1, -1] if none covers.
  return [bestStart, bestEnd];
}