Insert, Delete, and Get Random in Constant Time

Implement a set of integers that supports each of the following operations in average constant time:
insert x adds x when it is absent and otherwise leaves the set unchanged.
remove x deletes x when it is present and otherwise leaves the set unchanged.
getRandom returns one uniformly random value from the current set.
Process the commands in operations from left to right, starting from an empty set. Append one result for every command:
For insert x, append "true" if x was absent and became inserted, otherwise append "false".
For remove x, append "true" if x was present and became removed, otherwise append "false".
For getRandom, append the unique remaining value as a decimal integer string.
Every getRandom command is issued only when the set currently contains exactly one value, so the judged output is deterministic. Design the structure so that a later getRandom on a larger set would still be average O(1); the tests never ask for a stochastic sample from a multi-value set.
Each command is exactly insert x, remove x, or getRandom, where x is a signed decimal integer.
What the interview report shared
The Superday report asked to design a data structure that can put, delete, and get a random element, each in O(1).

Function
processRandomizedSet(operations: String[]) → String[]

Examples
Example 1
operations = ["insert 1","insert 2","remove 1","getRandom"]
return = ["true","true","true","2"]
Inserting 1 and 2 both succeed. Removing 1 leaves only 2, so getRandom must return 2.
Example 2
operations = ["insert 3","remove 4","insert 3","getRandom"]
return = ["true","false","false","3"]
The first insert creates singleton 3. Removing missing 4 and inserting 3 again both return false. The set still holds only 3.

Constraints
1 <= operations.length <= 10^5.
Each operation is exactly insert x, remove x, or getRandom.
-10^9 <= x <= 10^9.
Every getRandom occurs only when the set currently has size 1.

The pattern is a hash map from value to array index, plus a dynamic array of values. Insert checks the map, appends to the array, records the index. Remove looks up the index, copies the last array element into that slot, updates the map entry for that moved element, pops the array, then deletes the removed key from the map. The edge case that breaks the naive version: when the removed value is itself the last element. If you update the map for the moved element after deleting, or delete before updating, you can resurrect a stale key. Order matters. Do the overwrite and map update first, then pop and erase. Also parse the commands carefully, since x can be negative. Output strings must be exactly true, false, or the integer. If you freeze on the swap order during the live OA, StealthCoder can hand you the clean version.

If you see this problem in your OA tomorrow, the play is to recognize the pattern in 30 seconds. StealthCoder buys you that recognition.