Distinct values in every window

from collections import defaultdict

def distinct_per_window(nums, k):
    count = defaultdict(int)          # value -> copies inside the window
    out = []
    for hi, x in enumerate(nums):
        count[x] += 1                 # x enters
        if hi >= k:
            y = nums[hi - k]          # y leaves
            count[y] -= 1
            if count[y] == 0:
                del count[y]          # its last copy has gone
        if hi >= k - 1:
            out.append(len(count))
    return out

#include <vector>
#include <unordered_map>

std::vector<int> solve(const std::vector<int>& nums, int k) {
    std::unordered_map<int, int> count;           // value -> copies inside the window
    std::vector<int> out;
    for (int hi = 0; hi < (int)nums.size(); ++hi) {
        ++count[nums[hi]];                        // enters
        if (hi >= k) {
            auto it = count.find(nums[hi - k]);   // leaves
            if (--it->second == 0) count.erase(it);
        }
        if (hi >= k - 1) out.push_back((int)count.size());
    }
    return out;
}

import java.util.*;

class Solution {
    public int[] distinctPerWindow(int[] nums, int k) {
        Map<Integer, Integer> count = new HashMap<>();     // value -> copies inside the window
        int[] out = new int[nums.length - k + 1];
        for (int hi = 0; hi < nums.length; hi++) {
            count.merge(nums[hi], 1, Integer::sum);        // enters
            if (hi >= k) {
                int y = nums[hi - k];                      // leaves
                if (count.merge(y, -1, Integer::sum) == 0) count.remove(y);
            }
            if (hi >= k - 1) out[hi - k + 1] = count.size();
        }
        return out;
    }
}

function distinctPerWindow(nums, k) {
  const count = new Map();             // value -> copies inside the window
  const out = [];
  for (let hi = 0; hi < nums.length; hi++) {
    count.set(nums[hi], (count.get(nums[hi]) || 0) + 1);     // enters
    if (hi >= k) {
      const y = nums[hi - k], c = count.get(y) - 1;          // leaves
      if (c === 0) count.delete(y); else count.set(y, c);
    }
    if (hi >= k - 1) out.push(count.size);
  }
  return out;
}

use std::collections::HashMap;

fn solve(nums: &[i64], k: usize) -> Vec<usize> {
    let mut count: HashMap<i64, usize> = HashMap::new();   // value -> copies inside the window
    let mut out = Vec::new();
    for hi in 0..nums.len() {
        *count.entry(nums[hi]).or_insert(0) += 1;          // enters
        if hi >= k {
            let y = nums[hi - k];                          // leaves
            let c = count.get_mut(&y).unwrap();
            *c -= 1;
            if *c == 0 { count.remove(&y); }
        }
        if hi + 1 >= k { out.push(count.len()); }
    }
    out
}

import qualified Data.Map.Strict as M

-- Pair each value with the one leaving the window; keep counts with zeros removed.
solve :: [Int] -> Int -> [Int]
solve xs k = drop (k - 1) (map M.size (tail (scanl step M.empty pairs)))
  where
    pairs = zip xs (replicate k Nothing ++ map Just xs)
    step m (x, out) = maybe id dec out (M.insertWith (+) x 1 m)
    dec y = M.update (\c -> if c == 1 then Nothing else Just (c - 1)) y