Find every value that appears twice

def all_duplicates(nums):
    out = []
    for x in nums:
        j = abs(x) - 1              # an earlier step may have flipped this slot
        if nums[j] < 0:
            out.append(abs(x))      # second time we've met this value
        else:
            nums[j] = -nums[j]      # first time: mark it
    return sorted(out)

#include <algorithm>
#include <cstdlib>
#include <vector>
using namespace std;

vector<int> solve(vector<int> nums) {
    vector<int> out;
    for (size_t i = 0; i < nums.size(); i++) {
        int j = abs(nums[i]) - 1;          // an earlier step may have flipped this slot
        if (nums[j] < 0) out.push_back(j + 1);
        else nums[j] = -nums[j];           // first time: mark it
    }
    sort(out.begin(), out.end());
    return out;
}

import java.util.*;

class Solution {
    public int[] allDuplicates(int[] nums) {
        List<Integer> out = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
            int j = Math.abs(nums[i]) - 1;   // an earlier step may have flipped this slot
            if (nums[j] < 0) out.add(j + 1);
            else nums[j] = -nums[j];         // first time: mark it
        }
        int[] r = new int[out.size()];
        for (int i = 0; i < r.length; i++) r[i] = out.get(i);
        Arrays.sort(r);
        return r;
    }
}

function allDuplicates(nums) {
  const out = [];
  for (let i = 0; i < nums.length; i++) {
    const j = Math.abs(nums[i]) - 1;   // an earlier step may have flipped this slot
    if (nums[j] < 0) out.push(j + 1);  // second time we've met this value
    else nums[j] = -nums[j];           // first time: mark it
  }
  return out.sort((a, b) => a - b);
}

fn solve(nums: &[i32]) -> Vec<i32> {
    let mut a = nums.to_vec();
    let mut out = Vec::new();
    for i in 0..a.len() {
        let j = (a[i].abs() - 1) as usize; // an earlier step may have flipped this slot
        if a[j] < 0 {
            out.push(j as i32 + 1);
        } else {
            a[j] = -a[j]; // first time: mark it
        }
    }
    out.sort();
    out
}

import qualified Data.IntMap.Strict as M

-- Pure Haskell has no cheap in-place sign flip, so this counts with a map. The O(1)-space
-- version needs a mutable array in ST; the marking idea is the same.
solve :: [Int] -> [Int]
solve xs = [v | (v, c) <- M.toAscList counts, c == 2]
  where
    counts = M.fromListWith (+) [(x, 1 :: Int) | x <- xs]