Shortest window containing every letter

from collections import Counter

def min_window_cover(s, t):
    need = Counter(t)             # how many of each character the window still needs
    missing = len(t)              # total still needed
    best = 0
    left = 0
    for right, c in enumerate(s):
        if need[c] > 0:
            missing -= 1
        need[c] -= 1
        while missing == 0:                      # valid: record, then shrink
            size = right - left + 1
            if best == 0 or size < best:
                best = size
            d = s[left]
            need[d] += 1
            if need[d] > 0:                       # the window needs d again
                missing += 1
            left += 1
    return best

#include <string>

int solve(const std::string& s, const std::string& t) {
    int need[128] = {0};
    for (unsigned char c : t) need[c]++;
    int missing = static_cast<int>(t.size()), best = 0, left = 0;
    for (int right = 0; right < static_cast<int>(s.size()); ++right) {
        unsigned char c = s[right];
        if (need[c] > 0) --missing;
        --need[c];
        while (missing == 0) {                   // valid: record, then shrink
            int size = right - left + 1;
            if (best == 0 || size < best) best = size;
            unsigned char d = s[left++];
            if (++need[d] > 0) ++missing;        // the window needs d again
        }
    }
    return best;
}

class Solution {
    public int minWindowCover(String s, String t) {
        int[] need = new int[128];
        for (char c : t.toCharArray()) need[c]++;
        int missing = t.length(), best = 0, left = 0;
        for (int right = 0; right < s.length(); right++) {
            char c = s.charAt(right);
            if (need[c] > 0) missing--;
            need[c]--;
            while (missing == 0) {                     // valid: record, then shrink
                int size = right - left + 1;
                if (best == 0 || size < best) best = size;
                char d = s.charAt(left++);
                if (++need[d] > 0) missing++;          // the window needs d again
            }
        }
        return best;
    }
}

function minWindowCover(s, t) {
  const need = new Map();
  for (const c of t) need.set(c, (need.get(c) || 0) + 1);
  let missing = t.length, best = 0, left = 0;
  for (let right = 0; right < s.length; right++) {
    const c = s[right];
    if ((need.get(c) || 0) > 0) missing--;
    need.set(c, (need.get(c) || 0) - 1);
    while (missing === 0) {                     // valid: record, then shrink
      const size = right - left + 1;
      if (best === 0 || size < best) best = size;
      const d = s[left++];
      need.set(d, need.get(d) + 1);
      if (need.get(d) > 0) missing++;           // the window needs d again
    }
  }
  return best;
}

fn solve(s: &str, t: &str) -> usize {
    let s = s.as_bytes();
    let mut need = [0i64; 128];
    for &c in t.as_bytes() {
        need[c as usize] += 1;
    }
    let (mut missing, mut best, mut left) = (t.len(), 0usize, 0usize);
    for right in 0..s.len() {
        let c = s[right] as usize;
        if need[c] > 0 {
            missing -= 1;
        }
        need[c] -= 1;
        while missing == 0 {                          // valid: record, then shrink
            let size = right - left + 1;
            if best == 0 || size < best {
                best = size;
            }
            let d = s[left] as usize;
            left += 1;
            need[d] += 1;
            if need[d] > 0 {
                missing += 1;                         // the window needs d again
            }
        }
    }
    best
}

import Data.Array
import qualified Data.Map.Strict as M

solve :: String -> String -> Int
solve s t = go 0 0 need0 (length t) 0
  where
    n = length s
    arr = listArray (0, n - 1) s
    need0 = M.fromListWith (+) [(c, 1 :: Int) | c <- t]
    get m c = M.findWithDefault 0 c m
    -- right is the next index to add; while nothing is missing, shrink from the left
    go left right need missing best
      | missing == 0 =
          let size = right - left
              best' = if best == 0 || size < best then size else best
              d = arr ! left
              need' = M.insert d (get need d + 1) need
              missing' = if get need' d > 0 then missing + 1 else missing
          in go (left + 1) right need' missing' best'
      | right == n = best
      | otherwise =
          let c = arr ! right
              missing' = if get need c > 0 then missing - 1 else missing
              need' = M.insert c (get need c - 1) need
          in go left (right + 1) need' missing' best