Random Pick Index

Random Pick Index - Problem

Given an integer array nums with possible duplicates, randomly output the index of a given target number. You can assume that the given target number must exist in the array.

Implement the Solution class:

Solution(int[] nums) Initializes the object with the array nums.
int pick(int target) Picks a random index i from nums where nums[i] == target. If there are multiple valid indices, then each index should have an equal probability of returning.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,2,3,3,3], target = 3

› Output: One of [2,3,4]

💡 Note: Target 3 appears at indices 2, 3, 4. Each index should be returned with equal 1/3 probability

Example 2 — Single Occurrence

$ Input: nums = [1,2,3,3,3], target = 1

› Output: 0

💡 Note: Target 1 appears only at index 0, so we must return 0

Example 3 — Multiple Duplicates

$ Input: nums = [1,1,1,1,1], target = 1

› Output: One of [0,1,2,3,4]

💡 Note: Target 1 appears at all indices. Each index should be returned with equal 1/5 probability

Constraints

1 ≤ nums.length ≤ 2×10⁴
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
target is guaranteed to exist in nums

Visualization

Tap to expand

Asked in

f Facebook 35 G Google 28 a Amazon 22 M Microsoft 18

The key insight is ensuring equal probability when multiple indices contain the target value. The hash map approach offers O(1) pick time after preprocessing, while reservoir sampling provides O(1) space with mathematical elegance. Time: O(n) for single query, Space: O(1) to O(n) depending on approach.

Common Approaches

✓ Hash Map Preprocessing

⏱️ Time: O(1) Space: O(n)

During initialization, build a hash map where each key is a number and value is a list of all indices where that number appears. For pick operations, directly access the list and randomly select an index.

Linear Scan Every Time

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

For each pick operation, iterate through the entire array to collect all indices where nums[i] equals target, then use random selection to pick one of these indices.

Reservoir Sampling

⏱️ Time: O(n) Space: O(1)

Reservoir sampling allows us to randomly select one item from a stream of unknown length, ensuring each item has equal probability of selection. We iterate through array once, keeping track of count of target occurrences and probabilistically replacing our current choice.

Hash Map Preprocessing — Algorithm Steps

Build hash map: value → list of indices
For pick: access target's index list
Generate random index to select from the list

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Map

Create value → indices mapping during initialization

Direct Access

Look up target value to get all its indices

Random Select

Pick random index from the pre-stored list

Code -

solution.c — C

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

#define MAX_NUMS 20000
#define HASH_SIZE 10007

typedef struct Entry {
    int key;
    int indices[MAX_NUMS];
    int count;
    struct Entry* next;
} Entry;

typedef struct {
    Entry* hashTable[HASH_SIZE];
} Solution;

int hash_func(int key) {
    return (key % HASH_SIZE + HASH_SIZE) % HASH_SIZE;
}

Solution* solutionCreate(int* nums, int numsSize) {
    Solution* obj = (Solution*)malloc(sizeof(Solution));
    memset(obj->hashTable, 0, sizeof(obj->hashTable));
    
    for (int i = 0; i < numsSize; i++) {
        int h = hash_func(nums[i]);
        Entry* curr = obj->hashTable[h];
        
        while (curr != NULL) {
            if (curr->key == nums[i]) {
                curr->indices[curr->count++] = i;
                goto next_iteration;
            }
            curr = curr->next;
        }
        
        Entry* newEntry = (Entry*)malloc(sizeof(Entry));
        newEntry->key = nums[i];
        newEntry->indices[0] = i;
        newEntry->count = 1;
        newEntry->next = obj->hashTable[h];
        obj->hashTable[h] = newEntry;
        
        next_iteration:;
    }
    
    return obj;
}

int solutionPick(Solution* obj, int target) {
    int h = hash_func(target);
    Entry* curr = obj->hashTable[h];
    
    while (curr != NULL) {
        if (curr->key == target) {
            return curr->indices[rand() % curr->count];
        }
        curr = curr->next;
    }
    return -1;
}

void solutionFree(Solution* obj) {
    for (int i = 0; i < HASH_SIZE; i++) {
        Entry* curr = obj->hashTable[i];
        while (curr != NULL) {
            Entry* temp = curr;
            curr = curr->next;
            free(temp);
        }
    }
    free(obj);
}

static char line[100000];
static int nums[MAX_NUMS];

int parseArray(char* line, int* nums) {
    int count = 0;
    char* p = line;
    
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        int sign = 1;
        if (*p == '-') {
            sign = -1;
            p++;
        }
        
        int num = 0;
        while (*p >= '0' && *p <= '9') {
            num = num * 10 + (*p - '0');
            p++;
        }
        nums[count++] = sign * num;
    }
    
    return count;
}

int main() {
    srand(time(NULL));
    
    if (!fgets(line, sizeof(line), stdin)) {
        return 1;
    }
    
    int numsSize = parseArray(line, nums);
    
    int target;
    if (scanf("%d", &target) != 1) {
        return 1;
    }
    
    Solution* obj = solutionCreate(nums, numsSize);
    printf("%d\n", solutionPick(obj, target));
    solutionFree(obj);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Pick operation is O(1) average time after O(n) preprocessing

✓ Linear Growth

Space Complexity

O(n)

Hash map stores all n indices distributed across different keys

⚡ Linearithmic Space

64.5K Views

Medium Frequency

~15 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

Hash Map Preprocessing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler