Random Pick with Blacklist

Random Pick with Blacklist - Problem

Array Hash Table Math Binary Search Sorting Randomized Hard

You are given an integer n and an array of unique integers blacklist. Design an algorithm to pick a random integer in the range [0, n - 1] that is not in blacklist.

Any integer that is in the mentioned range and not in blacklist should be equally likely to be returned.

Optimize your algorithm such that it minimizes the number of calls to the built-in random function of your language.

Implement the Solution class:

Solution(int n, int[] blacklist) Initializes the object with the integer n and the blacklisted integers blacklist.
int pick() Returns a random integer in the range [0, n - 1] and not in blacklist.

Input & Output

Example 1 — Basic Case

$ Input: n = 7, blacklist = [2, 3, 5]

› Output: Random valid number from {0, 1, 4, 6}

💡 Note: Valid numbers are 0, 1, 4, 6. Each should be returned with equal probability 1/4.

Example 2 — Small Range

$ Input: n = 4, blacklist = [1]

› Output: Random valid number from {0, 2, 3}

💡 Note: Only number 1 is blacklisted, so valid choices are 0, 2, 3 with probability 1/3 each.

Example 3 — Empty Blacklist

$ Input: n = 3, blacklist = []

› Output: Random valid number from {0, 1, 2}

💡 Note: No blacklist means all numbers 0, 1, 2 are valid with equal probability 1/3.

Constraints

1 ≤ n ≤ 10⁹
0 ≤ blacklist.length ≤ min(10⁵, n - 1)
0 ≤ blacklist[i] < n
All values in blacklist are unique

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8 M Microsoft 6

The optimal solution uses virtual mapping where blacklisted positions in range [0, M-1] map to valid positions in [M, n-1], where M = n - blacklist.length. This ensures O(1) pick() time with exactly one random call. Time: O(k) initialization, O(1) pick. Space: O(k).

Common Approaches

✓ Binary Search with Index Adjustment

⏱️ Time: O(n) Space: O(n-k)

Create a sorted whitelist of all valid numbers, then generate random index and use binary search to find the corresponding valid number efficiently.

Brute Force - Keep Trying

⏱️ Time: O(∞) Space: O(k)

For each pick() call, generate random numbers in [0, n-1] and check if it's blacklisted. Keep trying until we find a valid number.

Virtual Whitelist Mapping

⏱️ Time: O(k) Space: O(k)

Create a mapping where blacklisted numbers in range [0, M-1] map to valid numbers from [M, n-1], where M = n - blacklist_size. This ensures we can pick randomly from [0, M-1] and always get a valid result.

Binary Search with Index Adjustment — Algorithm Steps

Build sorted whitelist of all non-blacklisted numbers
Generate random index in [0, whitelist.length-1]
Return whitelist[random_index] directly

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Whitelist

Collect all valid numbers into array

Generate Random Index

Pick random position in whitelist

Return Value

Return whitelist[random_index]

Code -

solution.c — C

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

static int blacklist[100000];
static int blacklistSize;
static int validCount;

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int binarySearchBlacklist(int num) {
    int left = 0, right = blacklistSize;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (blacklist[mid] <= num) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int isBlacklisted(int num) {
    int left = 0, right = blacklistSize - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (blacklist[mid] == num) {
            return 1;
        } else if (blacklist[mid] < num) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return 0;
}

int countValidUpTo(int num) {
    if (num < 0) return 0;
    
    int total = num + 1;
    int blacklisted = binarySearchBlacklist(num);
    
    return total - blacklisted;
}

int findKthValid(int n, int k) {
    if (blacklistSize == 0) {
        return k;
    }
    
    int left = 0, right = n - 1;
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        int validCount = countValidUpTo(mid);
        
        if (validCount <= k) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    
    // Now left points to a position where we have exactly k+1 valid numbers <= left
    while (left < n && isBlacklisted(left)) {
        left++;
    }
    
    return left;
}

int solution(int n) {
    qsort(blacklist, blacklistSize, sizeof(int), compare);
    validCount = n - blacklistSize;
    
    srand(time(NULL));
    
    // Pick a random index among valid numbers
    int k = rand() % validCount;
    return findKthValid(n, k);
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[10000];
    scanf(" %s", line);
    
    blacklistSize = 0;
    
    if (strcmp(line, "[]") != 0) {
        char* p = line + 1; // skip '['
        while (*p && *p != ']') {
            while (*p == ',' || *p == ' ') p++;
            if (*p == ']' || *p == '\0') break;
            
            char* endp;
            long val = strtol(p, &endp, 10);
            if (p != endp) {
                blacklist[blacklistSize++] = (int)val;
                p = endp;
            } else {
                break;
            }
        }
    }
    
    printf("%d\n", solution(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Initialization takes O(n) to build whitelist, pick() is O(1)

✓ Linear Growth

Space Complexity

O(n-k)

Whitelist array stores all n-k valid numbers

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

890 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

Binary Search with Index Adjustment — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler