Shortest window holding every kind

def shortest_all_kinds(s):
    need = len(set(s))
    count = [0] * 26
    have = lo = 0
    best = len(s)
    for hi, c in enumerate(s):
        count[ord(c) - 97] += 1
        if count[ord(c) - 97] == 1:
            have += 1
        while have == need:                 # valid: record, then try a shorter one
            best = min(best, hi - lo + 1)
            count[ord(s[lo]) - 97] -= 1
            if count[ord(s[lo]) - 97] == 0:
                have -= 1
            lo += 1
    return best

#include <string>
#include <array>
#include <algorithm>

int solve(const std::string& s) {
    std::array<int, 26> seen{}, count{};
    int need = 0;
    for (char c : s) if (seen[c - 'a']++ == 0) ++need;
    int have = 0, lo = 0, best = (int)s.size();
    for (int hi = 0; hi < (int)s.size(); ++hi) {
        if (++count[s[hi] - 'a'] == 1) ++have;
        while (have == need) {                    // valid: record, then try a shorter one
            best = std::min(best, hi - lo + 1);
            if (--count[s[lo] - 'a'] == 0) --have;
            ++lo;
        }
    }
    return best;
}

class Solution {
    public int shortestAllKinds(String s) {
        int[] seen = new int[26], count = new int[26];
        int need = 0;
        for (char c : s.toCharArray()) if (seen[c - 'a']++ == 0) need++;
        int have = 0, lo = 0, best = s.length();
        for (int hi = 0; hi < s.length(); hi++) {
            if (++count[s.charAt(hi) - 'a'] == 1) have++;
            while (have == need) {                  // valid: record, then try a shorter one
                best = Math.min(best, hi - lo + 1);
                if (--count[s.charAt(lo) - 'a'] == 0) have--;
                lo++;
            }
        }
        return best;
    }
}

function shortestAllKinds(s) {
  const need = new Set(s).size, count = new Array(26).fill(0);
  let have = 0, lo = 0, best = s.length;
  for (let hi = 0; hi < s.length; hi++) {
    if (++count[s.charCodeAt(hi) - 97] === 1) have++;
    while (have === need) {                  // valid: record, then try a shorter one
      best = Math.min(best, hi - lo + 1);
      if (--count[s.charCodeAt(lo) - 97] === 0) have--;
      lo++;
    }
  }
  return best;
}

fn solve(s: &str) -> usize {
    let b = s.as_bytes();
    let mut seen = [false; 26];
    let mut need = 0;
    for &c in b { if !seen[(c - b'a') as usize] { seen[(c - b'a') as usize] = true; need += 1; } }
    let mut count = [0usize; 26];
    let (mut have, mut lo, mut best) = (0, 0usize, b.len());
    for hi in 0..b.len() {
        count[(b[hi] - b'a') as usize] += 1;
        if count[(b[hi] - b'a') as usize] == 1 { have += 1; }
        while have == need && need > 0 {          // valid: record, then try a shorter one
            best = best.min(hi + 1 - lo);
            count[(b[lo] - b'a') as usize] -= 1;
            if count[(b[lo] - b'a') as usize] == 0 { have -= 1; }
            lo += 1;
        }
    }
    best
}

import qualified Data.Map.Strict as M
import Data.List (nub)

-- Fold over the letters carrying (counts, letters from the window's left end, window length, best).
-- After each letter enters, shrink while the window still covers every kind, recording each length.
solve :: String -> Int
solve s = best
  where
    need = length (nub s)
    (_, _, _, best) = foldl step (M.empty, s, 0, length s) s
    step (m, win, n, b) c = shrink (M.insertWith (+) c 1 m) win (n + 1) b
    shrink m win n b
      | M.size m == need, (x:xs) <- win =
          shrink (M.update (\k -> if k == 1 then Nothing else Just (k - 1)) x m) xs (n - 1) (min b n)
      | otherwise = (m, win, n, b)