Arrays and hashing

seen = {}                    # key -> whatever you need back
for i, x in enumerate(a):
    key = derive(x)          # the whole problem is choosing this
    if key in seen:
        use(seen[key], i)    # look up BEFORE inserting, or you match x with itself
    seen[key] = i

unordered_map<long long, int> seen;   // key -> whatever you need back
for (int i = 0; i < (int)a.size(); i++) {
    long long key = derive(a[i]);     // the whole problem is choosing this
    auto it = seen.find(key);
    if (it != seen.end()) use(it->second, i);   // look up before inserting
    seen[key] = i;
}

Map<Long, Integer> seen = new HashMap<>();   // key -> whatever you need back
for (int i = 0; i < a.length; i++) {
    long key = derive(a[i]);          // the whole problem is choosing this
    Integer prev = seen.get(key);
    if (prev != null) use(prev, i);   // look up before inserting
    seen.put(key, i);
}

const seen = new Map();          // key -> whatever you need back
for (let i = 0; i < a.length; i++) {
  const key = derive(a[i]);      // the whole problem is choosing this
  if (seen.has(key)) use(seen.get(key), i);   // look up before inserting
  seen.set(key, i);
}

let mut seen: HashMap<i64, usize> = HashMap::new();   // key -> what you need back
for (i, &x) in a.iter().enumerate() {
    let key = derive(x);                  // the whole problem is choosing this
    if let Some(&prev) = seen.get(&key) { use_it(prev, i); }   // look up before inserting
    seen.insert(key, i);
}

import qualified Data.Map.Strict as M

-- fold the array, carrying the map and the answer together
solve :: [Int] -> Int
solve = snd . foldl step (M.empty, 0) . zip [0 ..]
  where
    step (seen, acc) (i, x) =
      let key = derive x                      -- the whole problem is choosing this
          acc' = case M.lookup key seen of    -- look up before inserting
                   Just prev -> use prev i acc
                   Nothing   -> acc
      in (M.insert key i seen, acc')