Longest run of tasks within a time budget

def longest_within(times, budget):
    best = lo = total = 0
    for hi, t in enumerate(times):
        total += t
        while total > budget:          # over budget: drop tasks from the left
            total -= times[lo]
            lo += 1
        best = max(best, hi - lo + 1)  # 0 when the window is empty
    return best

#include <vector>
#include <algorithm>

int solve(const std::vector<int>& times, long long budget) {
    int best = 0, lo = 0;
    long long total = 0;
    for (int hi = 0; hi < (int)times.size(); ++hi) {
        total += times[hi];
        while (total > budget) total -= times[lo++];   // over budget: drop from the left
        best = std::max(best, hi - lo + 1);
    }
    return best;
}

class Solution {
    public int longestWithin(int[] times, long budget) {
        int best = 0, lo = 0;
        long total = 0;
        for (int hi = 0; hi < times.length; hi++) {
            total += times[hi];
            while (total > budget) total -= times[lo++];   // over budget: drop from the left
            best = Math.max(best, hi - lo + 1);
        }
        return best;
    }
}

function longestWithin(times, budget) {
  let best = 0, lo = 0, total = 0;
  for (let hi = 0; hi < times.length; hi++) {
    total += times[hi];
    while (total > budget) total -= times[lo++];   // over budget: drop from the left
    best = Math.max(best, hi - lo + 1);
  }
  return best;
}

fn solve(times: &[i64], budget: i64) -> usize {
    let (mut best, mut lo, mut total) = (0usize, 0usize, 0i64);
    for hi in 0..times.len() {
        total += times[hi];
        while total > budget {                 // over budget: drop from the left
            total -= times[lo];
            lo += 1;
        }
        best = best.max(hi + 1 - lo);
    }
    best
}

import Data.Array

-- Fold carrying (window start, total, best). Positive times guarantee the total
-- reaches 0 before lo passes hi, so the shrink always stops inside the array.
solve :: [Int] -> Int -> Int
solve ts budget = third (foldl step (0, 0, 0) (zip [0 ..] ts))
  where
    arr = listArray (0, length ts - 1) ts
    third (_, _, b) = b
    step (lo, total, best) (hi, t) =
      let (lo', total') = shrink lo (total + t)
      in (lo', total', max best (hi - lo' + 1))
    shrink lo total
      | total > budget = shrink (lo + 1) (total - arr ! lo)
      | otherwise      = (lo, total)