Longest run of ones after deleting one element

def longest_after_delete(bits):
    best = lo = zeros = 0
    for hi, b in enumerate(bits):
        zeros += b == 0
        while zeros > 1:               # at most one zero, the one we delete
            zeros -= bits[lo] == 0
            lo += 1
        best = max(best, hi - lo)      # window length minus the deleted element
    return best

#include <vector>
#include <algorithm>

int solve(const std::vector<int>& bits) {
    int best = 0, lo = 0, zeros = 0;
    for (int hi = 0; hi < (int)bits.size(); ++hi) {
        zeros += bits[hi] == 0;
        while (zeros > 1) zeros -= bits[lo++] == 0;   // at most one zero, the one we delete
        best = std::max(best, hi - lo);               // length minus the deleted element
    }
    return best;
}

class Solution {
    public int longestAfterDelete(int[] bits) {
        int best = 0, lo = 0, zeros = 0;
        for (int hi = 0; hi < bits.length; hi++) {
            if (bits[hi] == 0) zeros++;
            while (zeros > 1) if (bits[lo++] == 0) zeros--;   // at most one zero
            best = Math.max(best, hi - lo);                    // length minus the deleted element
        }
        return best;
    }
}

function longestAfterDelete(bits) {
  let best = 0, lo = 0, zeros = 0;
  for (let hi = 0; hi < bits.length; hi++) {
    if (bits[hi] === 0) zeros++;
    while (zeros > 1) if (bits[lo++] === 0) zeros--;   // at most one zero, the one we delete
    best = Math.max(best, hi - lo);                     // length minus the deleted element
  }
  return best;
}

fn solve(bits: &[i64]) -> 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 > 1 {                       // at most one zero, the one we delete
            if bits[lo] == 0 { zeros -= 1; }
            lo += 1;
        }
        best = best.max(hi - lo);               // length minus the deleted element
    }
    best
}

import Data.Array

-- The longest window with at most one zero, minus the element that must be deleted.
solve :: [Int] -> Int
solve bits = 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'))
    shrink lo z
      | z > 1     = shrink (lo + 1) (z - fromEnum (arr ! lo == 0))
      | otherwise = (lo, z)