Codestin Search App

Insert Delete GetRandom O(1) - Duplicates allowed - Problem

Imagine you need to build a smart bag that can hold multiple copies of the same item and perform three lightning-fast operations:

Insert: Add an item to the bag (even if it already exists)
Remove: Take out one copy of a specific item (if it exists)
Get Random: Pull out a completely random item, where items with more copies have higher chances of being selected

The challenge? Each operation must work in O(1) average time complexity!

Your task: Implement the RandomizedCollection class that supports duplicates (multiset) with these methods:

insert(val) - Returns true if val wasn't present before, false if it was already there
remove(val) - Returns true if val was found and removed, false if not found
getRandom() - Returns a random element where probability is proportional to frequency

This is the advanced version of the classic RandomizedSet problem, now supporting duplicates!

Input & Output

example_1.py — Basic Operations

$ Input: randomizedCollection = new RandomizedCollection(); randomizedCollection.insert(1); // return true since 1 is not present randomizedCollection.insert(1); // return false since 1 is already present randomizedCollection.insert(2); // return true since 2 is not present randomizedCollection.getRandom(); // return 1 or 2 randomly

› Output: [null, true, false, true, 1 or 2]

💡 Note: The collection starts empty. First insert(1) returns true as 1 wasn't present. Second insert(1) returns false as 1 was already there. insert(2) returns true as 2 is new. getRandom() can return either 1 or 2, with 1 having higher probability since it appears twice.

example_2.py — Remove Operations

$ Input: randomizedCollection = new RandomizedCollection(); randomizedCollection.insert(1); // [1], return true randomizedCollection.insert(1); // [1,1], return false randomizedCollection.insert(2); // [1,1,2], return true randomizedCollection.remove(1); // [1,2], return true randomizedCollection.remove(1); // [2], return true randomizedCollection.remove(1); // [2], return false

› Output: [null, true, false, true, true, true, false]

💡 Note: After inserting 1,1,2 we have [1,1,2]. First remove(1) removes one copy, leaving [1,2]. Second remove(1) removes the last 1, leaving [2]. Third remove(1) returns false as no 1 exists.

example_3.py — Probability Distribution

$ Input: randomizedCollection = new RandomizedCollection(); randomizedCollection.insert(1); // [1] randomizedCollection.insert(1); // [1,1] randomizedCollection.insert(1); // [1,1,1] randomizedCollection.insert(2); // [1,1,1,2] randomizedCollection.getRandom(); // should return 1 with 75% probability, 2 with 25%

› Output: [null, true, false, false, true, 1 (75% chance) or 2 (25% chance)]

💡 Note: The collection contains [1,1,1,2]. Since 1 appears 3 times out of 4 total elements, getRandom() should return 1 with probability 3/4 = 75% and 2 with probability 1/4 = 25%.

Constraints

-2³¹ ≤ val ≤ 2³¹ - 1
At most 2 * 10⁵ calls will be made to insert, remove, and getRandom
getRandom will not be called if the collection is empty
Each test case will have at least one call to insert before any call to getRandom

Visualization

Tap to expand

Understanding the Visualization

Setup

The machine has a tube to store balls in order and a catalog to track where each number's balls are located

Adding Balls

New balls are always added to the end of the tube, and their positions are recorded in the catalog

Removing Balls

To remove a ball, we swap it with the last ball in the tube, update the catalog, and remove the last position

Random Draw

Pick a random position in the tube and return that ball - higher frequency numbers have proportionally higher chances

Key Takeaway

🎯 Key Insight: By combining array indexing (for instant random access) with hash map position tracking (for instant removal), we achieve O(1) performance for all operations while maintaining proper probability distribution for duplicates!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution combines an array for O(1) random access with a hash map tracking index sets for each value. This enables all operations to run in O(1) average time while properly handling duplicates. The key insight is using the swap-with-last technique for efficient removal without shifting elements.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Simple List)	O(n)	O(n)	Store all elements in a simple list, search linearly for operations
Array + HashMap (Optimal)	O(1)	O(n)	Combine array for O(1) random access with hash map tracking positions

Brute Force (Simple List) — Algorithm Steps

Use a list to store all elements including duplicates
Insert: Append element to the end of list
Remove: Linear search to find element, remove first occurrence
GetRandom: Generate random index and return element at that position

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Empty list ready for operations

Insert Operations

Elements are appended to the end of the list

Remove Operation

Linear search through list to find and remove element

GetRandom Operation

Generate random index and return element

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>

typedef struct {
    int* data;
    int size;
    int capacity;
} RandomizedCollection;

RandomizedCollection* randomizedCollectionCreate() {
    RandomizedCollection* obj = malloc(sizeof(RandomizedCollection));
    obj->capacity = 10;
    obj->data = malloc(obj->capacity * sizeof(int));
    obj->size = 0;
    srand(time(NULL));
    return obj;
}

bool randomizedCollectionInsert(RandomizedCollection* obj, int val) {
    bool wasPresent = false;
    for (int i = 0; i < obj->size; i++) {
        if (obj->data[i] == val) {
            wasPresent = true;
            break;
        }
    }
    
    if (obj->size == obj->capacity) {
        obj->capacity *= 2;
        obj->data = realloc(obj->data, obj->capacity * sizeof(int));
    }
    
    obj->data[obj->size++] = val;
    return !wasPresent;
}

bool randomizedCollectionRemove(RandomizedCollection* obj, int val) {
    for (int i = 0; i < obj->size; i++) {
        if (obj->data[i] == val) {
            for (int j = i; j < obj->size - 1; j++) {
                obj->data[j] = obj->data[j + 1];
            }
            obj->size--;
            return true;
        }
    }
    return false;
}

int randomizedCollectionGetRandom(RandomizedCollection* obj) {
    int index = rand() % obj->size;
    return obj->data[index];
}

void randomizedCollectionFree(RandomizedCollection* obj) {
    free(obj->data);
    free(obj);
}

// Example usage:
// RandomizedCollection* collection = randomizedCollectionCreate();
// printf("%d\n", randomizedCollectionInsert(collection, 1)); // 1
// printf("%d\n", randomizedCollectionInsert(collection, 1)); // 0
// printf("%d\n", randomizedCollectionGetRandom(collection)); // 1

Time & Space Complexity

Time Complexity

⏱️

O(n)

Insert and getRandom are O(1), but remove is O(n) due to linear search

✓ Linear Growth

Space Complexity

O(n)

Need to store all n elements in the list

⚡ Linearithmic Space

89.6K Views

High Frequency

~35 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Simple List) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler