Random Pick with Blacklist - Practice Coding Problems

Random Pick with Blacklist - Problem

Array Hash Table Math Binary Search Sorting Randomized Hard

Random Pick with Blacklist

You're building a lottery system that needs to randomly select winners from a pool of participants, but some participants are disqualified (blacklisted). Your task is to design an efficient algorithm that can randomly pick a valid participant.

Given an integer n representing the total number of participants (numbered from 0 to n-1) and an array blacklist containing the IDs of disqualified participants, you need to:

1. Initialize your system with the total count and blacklist
2. Pick random participants efficiently, ensuring each valid participant has an equal chance

The key challenge is to minimize random function calls while maintaining perfect randomness. Each call to pick() should return a random integer in [0, n-1] that's not blacklisted.

Example:
If n = 7 and blacklist = [2, 3, 5], valid participants are [0, 1, 4, 6]. Each should have a 25% chance of being selected.

Input & Output

example_1.py — Basic Usage

$ Input: n = 7, blacklist = [2, 3, 5] Operations: ["Solution", "pick", "pick", "pick", "pick"]

› Output: Valid returns: any of [0, 1, 4, 6] for each pick

💡 Note: With n=7, we have indices [0,1,2,3,4,5,6]. Removing blacklisted [2,3,5] leaves [0,1,4,6]. Each pick() should return one of these 4 values with equal probability (25% each).

example_2.py — Edge Case Small

$ Input: n = 4, blacklist = [1, 3] Operations: ["Solution", "pick", "pick"]

› Output: Valid returns: any of [0, 2] for each pick

💡 Note: Only 2 valid numbers remain out of 4. The virtual array maps: original [0,1,2,3] with blacklist [1,3] becomes effective range [0,2) where index 1 is mapped to value 2.

example_3.py — Heavy Blacklist

$ Input: n = 10, blacklist = [0, 1, 2, 3, 4, 5, 6] Operations: ["Solution", "pick", "pick", "pick"]

› Output: Valid returns: any of [7, 8, 9] for each pick

💡 Note: Most numbers are blacklisted, leaving only [7,8,9]. The algorithm efficiently maps the small valid range [0,3) to these tail values, avoiding expensive rejection sampling.

Visualization

Tap to expand

Understanding the Visualization

Count Valid Tickets

Calculate how many valid tickets exist: validCount = n - blacklist.length

Identify Problem Tickets

Find blacklisted tickets in positions [0, validCount) - these block our random draw

Create Substitutions

Map each problematic ticket to a valid ticket from positions [validCount, n)

Draw and Substitute

Generate random in [0, validCount), apply substitution if needed

Key Takeaway

🎯 Key Insight: Instead of rejection sampling (which wastes random calls), create a virtual mapping that transforms any random number in [0, validCount) into a valid result. This guarantees O(1) performance and perfect uniform distribution!

Time & Space Complexity

Time Complexity

⏱️

O(b) initialization, O(1) per pick

Preprocessing takes O(blacklist_size), each pick is constant time with one random call

✓ Linear Growth

Space Complexity

O(b)

Store mapping for blacklisted numbers that fall in [0, validCount) range

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁹
0 ≤ blacklist.length ≤ min(10⁵, n - 1)
0 ≤ blacklist[i] < n
All values in blacklist are unique
At most 2 × 10⁴ calls will be made to pick

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal solution uses a clever virtual array mapping technique. Instead of repeatedly generating random numbers until finding a valid one, we create a mapping system that allows us to generate exactly one random number per pick. The key insight is to map blacklisted indices in the range [0, validCount) to valid values from the tail end [validCount, n). This achieves O(1) pick time with perfect uniform distribution.

Common Approaches

Approach	Time	Space	Notes
✓ Virtual Array Mapping (Optimal)	O(b) initialization, O(1) per pick	O(b)	Map blacklisted indices to valid values from the end of range
Rejection Sampling (Brute Force)	O(n/(n-b)) per pick on average, where b = blacklist size	O(b)	Keep generating random numbers until we get a valid one

Virtual Array Mapping (Optimal) — Algorithm Steps

Calculate validCount = n - len(blacklist)
Identify blacklisted numbers in [0, validCount) - these need remapping
Identify valid numbers in [validCount, n) - these are remap targets
Create mapping: blacklisted_in_range → valid_in_tail
For pick(): generate random in [0, validCount), return mapping if exists, else return number itself

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Valid Range

First validCount positions form our random range

Map Blacklisted

Map blacklisted positions to valid tail values

Random Pick

Generate in [0, validCount), apply mapping if needed

Code -

solution.c — C

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

#define MAX_MAPPING 1000

typedef struct {
    int key;
    int value;
} Pair;

typedef struct {
    int validCount;
    Pair mapping[MAX_MAPPING];
    int mappingSize;
} Solution;

Solution* solutionCreate(int n, int* blacklist, int blacklistSize) {
    Solution* obj = malloc(sizeof(Solution));
    obj->validCount = n - blacklistSize;
    obj->mappingSize = 0;
    
    // Find blacklisted numbers in range [validCount, n)
    bool* blacklistedInTail = calloc(n, sizeof(bool));
    for (int i = 0; i < blacklistSize; i++) {
        if (blacklist[i] >= obj->validCount) {
            blacklistedInTail[blacklist[i]] = true;
        }
    }
    
    // Create mapping for blacklisted numbers in [0, validCount)
    int tailIter = obj->validCount;
    for (int i = 0; i < blacklistSize; i++) {
        if (blacklist[i] < obj->validCount) {
            // Find next valid number in tail
            while (tailIter < n && blacklistedInTail[tailIter]) {
                tailIter++;
            }
            obj->mapping[obj->mappingSize].key = blacklist[i];
            obj->mapping[obj->mappingSize].value = tailIter;
            obj->mappingSize++;
            tailIter++;
        }
    }
    
    free(blacklistedInTail);
    srand(time(NULL));
    return obj;
}

int solutionPick(Solution* obj) {
    int randIdx = rand() % obj->validCount;
    
    // Check if randIdx has a mapping
    for (int i = 0; i < obj->mappingSize; i++) {
        if (obj->mapping[i].key == randIdx) {
            return obj->mapping[i].value;
        }
    }
    
    return randIdx;
}

void solutionFree(Solution* obj) {
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(b) initialization, O(1) per pick

Preprocessing takes O(blacklist_size), each pick is constant time with one random call

✓ Linear Growth

Space Complexity

O(b)

Store mapping for blacklisted numbers that fall in [0, validCount) range

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁹
0 ≤ blacklist.length ≤ min(10⁵, n - 1)
0 ≤ blacklist[i] < n
All values in blacklist are unique
At most 2 × 10⁴ calls will be made to pick

28.4K Views

Medium Frequency

~35 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Virtual Array Mapping (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler