Return every value that appears twice in an array, sorted in ascending order. Test your code, then compare with the explained solution. Free online practice.

Find All Duplicates in an Array

Reverse Words in a String

Valid Sudoku

Return every value that appears twice in an array, sorted in ascending order.

You are given an integer array `nums` of length `n` where every element is in the range `[1, n]`, and each integer appears either once or twice. Return an array of all the integers that appear twice. The returned array must be sorted in **ascending order**.

**Input / output**
- Input: `nums: int[]`
- Output: `int[]` containing every value that appears exactly twice, sorted ascending

## Example
```json
Input: {"nums":[4,3,2,7,8,2,3,1]}
Output: [2,3]
```

## Constraints
- `1 <= nums.length <= 10^5`
- `1 <= nums[i] <= nums.length`
- Each integer in `nums` appears either once or twice

## Follow-up
Can you solve it in `O(n)` time and `O(1)` extra space (not counting the output array), for example by marking visited values in place with `nums[abs(val) - 1] *= -1` and detecting when a position is already negative?

Every number is between `1` and `n`, and each value appears at most twice. That means you can either count what you have seen with extra memory, or reuse the input array itself as a visitation map by jumping to index `value - 1`.

Use the problem guarantees

Scan the array once, track values already seen, and append a value when it appears the second time. Because the final answer must be deterministic and sorted, sort the collected duplicates before returning them.

Warm up with a hash-set solution

For each value `val`, look at index `abs(val) - 1`. If that slot is still positive, negate it to mark that `val` has been seen once. If that slot is already negative, then `val` is appearing for the second time, so it belongs in the answer.

Reuse the array as the visited structure

This is the classic follow-up solution: detect duplicates in one pass by negating `nums[abs(val) - 1]`, collect values that hit an already-negative slot, then sort the output so the returned array is always in ascending order.