The best stretch to stay calm

def best_calm_stretch(customers, moody, k):
    base = sum(c for c, m in zip(customers, moody) if not m)   # satisfied anyway
    gain = [c * m for c, m in zip(customers, moody)]           # what a calm minute rescues
    window = sum(gain[:k])
    best = window
    for i in range(k, len(gain)):
        window += gain[i] - gain[i - k]
        best = max(best, window)
    return base + best

#include <vector>
#include <algorithm>

int solve(const std::vector<int>& customers, const std::vector<int>& moody, int k) {
    int n = (int)customers.size(), base = 0, window = 0;
    for (int i = 0; i < n; ++i) if (!moody[i]) base += customers[i];   // satisfied anyway
    auto gain = [&](int i) { return customers[i] * moody[i]; };        // rescued by calm
    for (int i = 0; i < k; ++i) window += gain(i);
    int best = window;
    for (int i = k; i < n; ++i) {
        window += gain(i) - gain(i - k);
        best = std::max(best, window);
    }
    return base + best;
}

class Solution {
    public int bestCalmStretch(int[] customers, int[] moody, int k) {
        int n = customers.length, base = 0, window = 0;
        for (int i = 0; i < n; i++) if (moody[i] == 0) base += customers[i];   // satisfied anyway
        for (int i = 0; i < k; i++) window += customers[i] * moody[i];
        int best = window;
        for (int i = k; i < n; i++) {
            window += customers[i] * moody[i] - customers[i - k] * moody[i - k];
            best = Math.max(best, window);
        }
        return base + best;
    }
}

function bestCalmStretch(customers, moody, k) {
  let base = 0, window = 0, best = 0;
  for (let i = 0; i < customers.length; i++) if (!moody[i]) base += customers[i];   // satisfied anyway
  const gain = i => customers[i] * moody[i];                                       // rescued by calm
  for (let i = 0; i < k; i++) window += gain(i);
  best = window;
  for (let i = k; i < customers.length; i++) {
    window += gain(i) - gain(i - k);
    best = Math.max(best, window);
  }
  return base + best;
}

fn solve(customers: &[i64], moody: &[i64], k: usize) -> i64 {
    let base: i64 = customers.iter().zip(moody).filter(|(_, &m)| m == 0).map(|(&c, _)| c).sum();
    let gain: Vec<i64> = customers.iter().zip(moody).map(|(&c, &m)| c * m).collect();
    let mut window: i64 = gain[..k].iter().sum();
    let mut best = window;
    for i in k..gain.len() {
        window += gain[i] - gain[i - k];
        best = best.max(window);
    }
    base + best
}

-- Satisfied anyway, plus the best fixed-width window over what calm minutes rescue.
solve :: [Int] -> [Int] -> Int -> Int
solve cs ms k = base + maximum (scanl step first (zip (drop k gain) gain))
  where
    base = sum [c | (c, m) <- zip cs ms, m == 0]
    gain = zipWith (*) cs ms
    first = sum (take k gain)
    step w (new, old) = w + new - old