Find every number from 1 to n that is missing

def all_missing(nums):
    for x in nums:
        j = abs(x) - 1                  # an earlier step may have flipped this slot
        nums[j] = -abs(nums[j])         # mark v as seen; stays negative on a repeat
    return [i + 1 for i, x in enumerate(nums) if x > 0]

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

vector<int> solve(vector<int> nums) {
    for (size_t i = 0; i < nums.size(); i++) {
        int j = abs(nums[i]) - 1;          // an earlier step may have flipped this slot
        nums[j] = -abs(nums[j]);           // mark v as seen; stays negative on a repeat
    }
    vector<int> out;
    for (size_t i = 0; i < nums.size(); i++)
        if (nums[i] > 0) out.push_back(i + 1);
    return out;
}

import java.util.*;

class Solution {
    public int[] allMissing(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            int j = Math.abs(nums[i]) - 1;   // an earlier step may have flipped this slot
            nums[j] = -Math.abs(nums[j]);    // mark v as seen; stays negative on a repeat
        }
        List<Integer> out = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) if (nums[i] > 0) out.add(i + 1);
        int[] r = new int[out.size()];
        for (int i = 0; i < r.length; i++) r[i] = out.get(i);
        return r;
    }
}

function allMissing(nums) {
  for (let i = 0; i < nums.length; i++) {
    const j = Math.abs(nums[i]) - 1;    // an earlier step may have flipped this slot
    nums[j] = -Math.abs(nums[j]);       // mark v as seen; stays negative on a repeat
  }
  const out = [];
  for (let i = 0; i < nums.length; i++) if (nums[i] > 0) out.push(i + 1);
  return out;
}

fn solve(nums: &[i32]) -> Vec<i32> {
    let mut a = nums.to_vec();
    for i in 0..a.len() {
        let j = (a[i].abs() - 1) as usize; // an earlier step may have flipped this slot
        a[j] = -a[j].abs(); // mark v as seen; stays negative on a repeat
    }
    (0..a.len()).filter(|&i| a[i] > 0).map(|i| i as i32 + 1).collect()
}

import qualified Data.IntSet as S

-- Pure Haskell has no cheap in-place sign flip, so this uses a set of what is present.
-- The O(1)-space version needs a mutable array in ST; the marking idea is the same.
solve :: [Int] -> [Int]
solve xs = [v | v <- [1 .. length xs], not (S.member v present)]
  where
    present = S.fromList xs