Random Pick Index - Practice Coding Problems

Random Pick Index - Problem

Random Pick Index is a fascinating problem that combines data structures with probability theory. You're given an integer array nums that may contain duplicate values, and your task is to implement a class that can randomly select an index for any given target number.

The challenge lies in ensuring uniform probability - if a target appears multiple times in the array, each occurrence should have an equal chance of being selected. For example, if the number 7 appears at indices [2, 5, 9], then each of these indices should have a 1/3 probability of being returned.

Your mission: Design a Solution class with two methods:
• Solution(int[] nums) - Initialize with the input array
• int pick(int target) - Return a random index where nums[index] == target

Input & Output

example_1.py — Basic Usage

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

› Output: 2 or 3 or 4 (each with 1/3 probability)

💡 Note: The target 3 appears at indices [2,3,4]. Each index should have equal probability of being returned, so valid outputs are 2, 3, or 4.

example_2.py — Single Occurrence

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

› Output: 1

💡 Note: The target 2 appears only at index 1, so we always return 1.

example_3.py — Multiple Calls

$ Input: nums = [1,2,3,3,3], multiple pick(3) calls

› Output: Various combinations of [2,3,4]

💡 Note: Over many calls, indices 2, 3, and 4 should each be returned approximately 1/3 of the time, demonstrating uniform random distribution.

Visualization

Tap to expand

Understanding the Visualization

Brute Force

Scan entire array each time - Simple but slow O(n) per pick

Hash Preprocessing

Build lookup table once - Fast O(1) picks but uses O(n) space

Reservoir Sampling

Mathematical elegance - O(1) space with uniform probability guarantee

Key Takeaway

🎯 Key Insight: Reservoir sampling achieves the seemingly impossible - uniform random selection from an unknown-size stream using only O(1) space through clever probability mathematics!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each pick() requires scanning the entire array once

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant amount of extra variables regardless of input size

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
target is guaranteed to exist in nums
At most 10⁴ calls will be made to pick

Asked in

G Google 45 a Amazon 38 f Facebook 32 ⊞ Microsoft 28

The Reservoir Sampling approach provides the optimal space complexity of O(1) while maintaining perfect uniform distribution. For applications requiring frequent queries, the Hash Table preprocessing approach offers O(1) pick time at the cost of O(n) space. Choose based on your space-time trade-off requirements.

Common Approaches

Approach	Time	Space	Notes
✓ Reservoir Sampling (Optimal)	O(n)	O(1)	Use reservoir sampling to pick random index in one pass with O(1) space
Hash Table Preprocessing	O(n) init + O(1) pick	O(n)	Build a hash map of value → indices during initialization for O(1) picks
Brute Force (Linear Scan Every Time)	O(n)	O(1)	Scan the entire array for each pick() call to find all matching indices

Reservoir Sampling (Optimal) — Algorithm Steps

Initialize result with -1 and count with 0
Iterate through the array once
When we find target at index i, increment count
With probability 1/count, update result to current index i
Continue until end of array and return result

Visualization

Tap to expand

Step-by-Step Walkthrough

1st match (idx 2)

count=1, keep with prob 1/1 = 100%

2nd match (idx 3)

count=2, keep with prob 1/2 = 50%

3rd match (idx 4)

count=3, keep with prob 1/3 = 33%

Final result

Each index has exactly 1/3 probability!

Code -

solution.c — C

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

typedef struct {
    int* nums;
    int size;
} Solution;

Solution* solutionCreate(int* nums, int numsSize) {
    Solution* obj = (Solution*)malloc(sizeof(Solution));
    obj->nums = nums;
    obj->size = numsSize;
    srand(time(NULL));
    return obj;
}

int solutionPick(Solution* obj, int target) {
    int result = -1;
    int count = 0;
    
    for (int i = 0; i < obj->size; i++) {
        if (obj->nums[i] == target) {
            count++;
            // With probability 1/count, choose current index
            if (rand() % count == 0) {
                result = i;
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each pick() requires scanning the entire array once

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant amount of extra variables regardless of input size

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
target is guaranteed to exist in nums
At most 10⁴ calls will be made to pick

67.2K Views

Medium-High Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Reservoir Sampling (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler