Randomized Collection with Duplicate Values

Process a finite operation sequence against a collection that stores duplicate integers.
INSERT adds values[i] and returns whether that value was absent before the operation.
REMOVE removes the oldest still-present occurrence of values[i] and returns whether an occurrence existed.
GET returns the element at index floorMod(values[i], size) in the collection's internal dense array. A GET operation is provided only when the collection is non-empty.
Removal fills the removed dense-array slot with the previous final element before shortening the array. Return one string per operation: "true" or "false" for mutations and the selected decimal integer for GET.
The injected integer on GET models a random-number source. Design insertion, removal, and indexed selection to run in expected O(1) time.

Function
randomizedCollectionOperations(operations: String[], values: int[]) → String[]

Examples
Example 1
operations = ["INSERT","INSERT","INSERT","REMOVE","GET"]
values = [1,1,2,1,3]
return = ["true","false","true","true","1"]
After removing one 1, the dense array contains two values. The injected draw 3 selects index 1.
Example 2
operations = ["REMOVE","INSERT","GET"]
values = [5,5,-1]
return = ["false","true","5"]
The first removal fails. With one stored value, every injected draw selects that value.
Example 3
operations = ["INSERT","INSERT","REMOVE","REMOVE","INSERT"]
values = [7,7,7,7,7]
return = ["true","false","true","true","true"]
After both occurrences are removed, inserting 7 again reports that it was absent.

Constraints
operations.length == values.length.
1 <= operations.length <= 100000.
Every operation is INSERT, REMOVE, or GET.
-10^9 <= values[i] <= 10^9.
Every GET occurs when the collection is non-empty.

The trick: keep an array of values and a map from value to the set of its positions in the array. Insert appends and adds the index to the set, returning true if the set was empty before. Remove takes an index of the value from the set, moves the last array element into that slot, updates the moved element's index set, then pops the array. GET is just arr[floorMod(v, size)]. The pitfall is the twist here: remove must drop the oldest still-present occurrence, so a plain unordered set may not match the expected output. Use an ordered structure per value, or reason carefully about which index is oldest after swaps. Also handle the case where the removed slot is the last element, or you'll delete and re-add the same index. And floorMod must be non-negative for negative inputs. StealthCoder is the hedge if the index bookkeeping falls apart under the live clock.

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