Longest run of ones after k flips

def longest_ones(bits, k):
    best = lo = zeros = 0
    for hi, b in enumerate(bits):
        zeros += b == 0
        while zeros > k:              # too many zeros to flip: shrink
            zeros -= bits[lo] == 0
            lo += 1
        best = max(best, hi - lo + 1)
    return best

#include <vector>
#include <algorithm>

int solve(const std::vector<int>& bits, int k) {
    int best = 0, lo = 0, zeros = 0;
    for (int hi = 0; hi < (int)bits.size(); ++hi) {
        zeros += bits[hi] == 0;
        while (zeros > k) zeros -= bits[lo++] == 0;   // too many zeros to flip: shrink
        best = std::max(best, hi - lo + 1);
    }
    return best;
}

class Solution {
    public int longestOnes(int[] bits, int k) {
        int best = 0, lo = 0, zeros = 0;
        for (int hi = 0; hi < bits.length; hi++) {
            if (bits[hi] == 0) zeros++;
            while (zeros > k) if (bits[lo++] == 0) zeros--;   // too many zeros to flip: shrink
            best = Math.max(best, hi - lo + 1);
        }
        return best;
    }
}

function longestOnes(bits, k) {
  let best = 0, lo = 0, zeros = 0;
  for (let hi = 0; hi < bits.length; hi++) {
    if (bits[hi] === 0) zeros++;
    while (zeros > k) {                // too many zeros to flip: shrink
      if (bits[lo] === 0) zeros--;
      lo++;
    }
    best = Math.max(best, hi - lo + 1);
  }
  return best;
}

fn solve(bits: &[i64], k: usize) -> usize {
    let (mut best, mut lo, mut zeros) = (0usize, 0usize, 0usize);
    for hi in 0..bits.len() {
        if bits[hi] == 0 { zeros += 1; }
        while zeros > k {                              // too many zeros to flip: shrink
            if bits[lo] == 0 { zeros -= 1; }
            lo += 1;
        }
        best = best.max(hi + 1 - lo);
    }
    best
}

import Data.Array

-- Fold carrying (window start, zeros inside, best); the left end is read from an array.
solve :: [Int] -> Int -> Int
solve bits k = third (foldl step (0, 0, 0) (zip [0 ..] bits))
  where
    arr = listArray (0, length bits - 1) bits
    third (_, _, b) = b
    step (lo, zeros, best) (hi, b) =
      let (lo', z') = shrink lo (zeros + fromEnum (b == 0))
      in (lo', z', max best (hi - lo' + 1))
    shrink lo z
      | z > k     = shrink (lo + 1) (z - fromEnum (arr ! lo == 0))
      | otherwise = (lo, z)