Longest run of one letter after k changes

def longest_repeat(s, k):
    count = [0] * 26
    lo = top = 0
    for hi, ch in enumerate(s):
        count[ord(ch) - 65] += 1
        top = max(top, count[ord(ch) - 65])   # the largest count ever seen; never lowered
        if hi - lo + 1 - top > k:              # too many changes: slide, do not shrink
            count[ord(s[lo]) - 65] -= 1
            lo += 1
    return len(s) - lo

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

int solve(const std::string& s, int k) {
    std::array<int, 26> count{};
    int lo = 0, top = 0;
    for (int hi = 0; hi < (int)s.size(); ++hi) {
        top = std::max(top, ++count[s[hi] - 'A']);   // the largest count ever seen; never lowered
        if (hi - lo + 1 - top > k) {                 // too many changes: slide, do not shrink
            --count[s[lo] - 'A'];
            ++lo;
        }
    }
    return (int)s.size() - lo;
}

class Solution {
    public int longestRepeat(String s, int k) {
        int[] count = new int[26];
        int lo = 0, top = 0;
        for (int hi = 0; hi < s.length(); hi++) {
            top = Math.max(top, ++count[s.charAt(hi) - 'A']);   // the largest count ever seen
            if (hi - lo + 1 - top > k) {                        // too many changes: slide
                count[s.charAt(lo) - 'A']--;
                lo++;
            }
        }
        return s.length() - lo;
    }
}

function longestRepeat(s, k) {
  const count = new Array(26).fill(0);
  let lo = 0, top = 0;
  for (let hi = 0; hi < s.length; hi++) {
    const i = s.charCodeAt(hi) - 65;
    top = Math.max(top, ++count[i]);           // the largest count ever seen; never lowered
    if (hi - lo + 1 - top > k) {               // too many changes: slide, do not shrink
      count[s.charCodeAt(lo) - 65]--;
      lo++;
    }
  }
  return s.length - lo;
}

fn solve(s: &str, k: usize) -> usize {
    let b = s.as_bytes();
    let mut count = [0usize; 26];
    let (mut lo, mut top) = (0usize, 0usize);
    for hi in 0..b.len() {
        let i = (b[hi] - b'A') as usize;
        count[i] += 1;
        top = top.max(count[i]);                 // the largest count ever seen; never lowered
        if hi + 1 - lo - top > k {               // too many changes: slide, do not shrink
            count[(b[lo] - b'A') as usize] -= 1;
            lo += 1;
        }
    }
    b.len() - lo
}

import qualified Data.Map.Strict as M

-- Fold carrying (counts, letters still in the window from its left end, window length, top).
-- The window slides rather than shrinks, so its final length is the answer.
solve :: String -> Int -> Int
solve s k = len
  where
    (_, _, len, _) = foldl step (M.empty, s, 0, 0) s
    step (m, win, n, top) c =
      let m1 = M.insertWith (+) c 1 m
          top' = max top (m1 M.! c)
          n1 = n + 1
      in if n1 - top' > k
           then case win of
                  (x:xs) -> (M.adjust (subtract 1) x m1, xs, n, top')
                  []     -> (m1, win, n1, top')
           else (m1, win, n1, top')