A repeated value within k positions

def nearby_repeat(nums, k):
    last = {}                       # value -> last index where it appeared
    for j, x in enumerate(nums):
        if x in last and j - last[x] <= k:   # look up first...
            return True
        last[x] = j                          # ...then record the newest index
    return False

#include <unordered_map>
#include <vector>
using namespace std;

bool solve(vector<int> nums, int k) {
    unordered_map<int, int> last;        // value -> last index
    for (int j = 0; j < (int)nums.size(); ++j) {
        auto it = last.find(nums[j]);
        if (it != last.end() && j - it->second <= k) return true;   // look up first...
        last[nums[j]] = j;                                          // ...then record
    }
    return false;
}

import java.util.*;

class Solution {
    public boolean nearbyRepeat(int[] nums, int k) {
        Map<Integer, Integer> last = new HashMap<>();   // value -> last index
        for (int j = 0; j < nums.length; j++) {
            Integer i = last.get(nums[j]);
            if (i != null && j - i <= k) return true;   // look up first...
            last.put(nums[j], j);                       // ...then record
        }
        return false;
    }
}

function nearbyRepeat(nums, k) {
  const last = new Map();         // value -> last index
  for (let j = 0; j < nums.length; j++) {
    const i = last.get(nums[j]);
    if (i !== undefined && j - i <= k) return true;   // look up first...
    last.set(nums[j], j);                             // ...then record
  }
  return false;
}

use std::collections::HashMap;

fn solve(nums: &[i32], k: usize) -> bool {
    let mut last: HashMap<i32, usize> = HashMap::new();   // value -> last index
    for (j, &x) in nums.iter().enumerate() {
        if let Some(&i) = last.get(&x) {
            if j - i <= k { return true; }                // look up first...
        }
        last.insert(x, j);                                // ...then record
    }
    false
}

import qualified Data.Map.Strict as M

solve :: [Int] -> Int -> Bool
solve xs k = go M.empty (zip [0..] xs)
  where
    -- the map holds the last index of every value seen so far
    go _ [] = False
    go m ((j, x):rest) = case M.lookup x m of
      Just i | j - i <= k -> True
      _                   -> go (M.insert x j m) rest