Best total over k consecutive days

def max_sum_k(nums, k):
    total = sum(nums[:k])            # the first window
    best = total
    for i in range(k, len(nums)):
        total += nums[i] - nums[i - k]   # one in, one out
        best = max(best, total)
    return best

#include <vector>
#include <algorithm>

long long solve(const std::vector<int>& nums, int k) {
    long long total = 0;
    for (int i = 0; i < k; ++i) total += nums[i];          // the first window
    long long best = total;
    for (int i = k; i < (int)nums.size(); ++i) {
        total += nums[i] - nums[i - k];                    // one in, one out
        best = std::max(best, total);
    }
    return best;
}

class Solution {
    public long maxSumK(int[] nums, int k) {
        long total = 0;
        for (int i = 0; i < k; i++) total += nums[i];      // the first window
        long best = total;
        for (int i = k; i < nums.length; i++) {
            total += nums[i] - nums[i - k];                // one in, one out
            best = Math.max(best, total);
        }
        return best;
    }
}

function maxSumK(nums, k) {
  let total = 0;
  for (let i = 0; i < k; i++) total += nums[i];   // the first window
  let best = total;
  for (let i = k; i < nums.length; i++) {
    total += nums[i] - nums[i - k];               // one in, one out
    best = Math.max(best, total);
  }
  return best;
}

fn solve(nums: &[i64], k: usize) -> i64 {
    let mut total: i64 = nums[..k].iter().sum();   // the first window
    let mut best = total;
    for i in k..nums.len() {
        total += nums[i] - nums[i - k];            // one in, one out
        best = best.max(total);
    }
    best
}

-- Each later window total is the previous one plus the element entering minus the one leaving.
solve :: [Int] -> Int -> Int
solve xs k = maximum (scanl step first (zip (drop k xs) xs))
  where
    first = sum (take k xs)
    step total (new, old) = total + new - old