Reservoir Sampling - Problem

Reservoir sampling is a classic algorithm used to randomly select k items from a stream of data where the total number of items is unknown or very large. The challenge is maintaining a uniform probability for each item to be selected without knowing how many items will come next.

Your task is to implement a reservoir sampling algorithm that processes a stream of integers and returns exactly k randomly selected items with equal probability for each item in the original stream.

The algorithm should work as follows:

Initialize a reservoir array of size k with the first k items from the stream
For each subsequent item (index i ≥ k), generate a random number between 0 and i (inclusive)
If the random number is less than k, replace the item at that position in the reservoir

Note: For testing purposes, use a simple random number generator based on a seed to ensure reproducible results.

Input & Output

Example 1 — Basic Stream

$ Input: stream = [1,2,3,4,5,6], k = 3

› Output: [1,2,6]

💡 Note: Reservoir sampling selects 3 items from the stream. Initially fills reservoir with [1,2,3]. When processing item 4 at index 3, generates random number in range [0,3]. If random < 3, replaces reservoir item. After processing all items, returns 3 selected elements.

Example 2 — Small k

$ Input: stream = [10,20,30,40,50], k = 2

› Output: [10,50]

💡 Note: Selects 2 items from 5-element stream. Starts with reservoir [10,20], then processes remaining items [30,40,50]. Each new item has probability k/(current_position+1) of replacing an existing reservoir item.

Example 3 — k equals stream length

$ Input: stream = [7,8,9], k = 3

› Output: [7,8,9]

💡 Note: When k equals or exceeds stream length, algorithm returns all stream elements since we can select everything without any sampling needed.

Constraints

1 ≤ stream.length ≤ 10⁴
1 ≤ k ≤ stream.length
-10⁶ ≤ stream[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Meta 28

The key insight is using reservoir sampling to maintain exactly k items with uniform selection probability from an unknown-length stream. The optimal approach processes items in a single pass, replacing reservoir items with decreasing probability. Time: O(n), Space: O(k).

Common Approaches

✓ Reservoir Sampling

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

Classic reservoir sampling algorithm that processes stream elements one by one, maintaining exactly k items with uniform selection probability.

Store All Then Sample

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

First pass through the stream stores all elements in an array. Once the stream ends, use random selection to pick k items from the stored array.

Reservoir Sampling — Algorithm Steps

Fill reservoir with first k items
For each new item i, generate random number 0 to i
If random < k, replace reservoir[random] with current item
Continue until stream ends

Visualization

Tap to expand

Step-by-Step Walkthrough

Fill Reservoir

Start with first k elements

Process Stream

For each new item, decide replacement

Final Reservoir

k items with uniform probability

Code -

solution.c — C

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

int* solution(int* stream, int streamSize, int k, int* returnSize) {
    *returnSize = 0;
    
    if (streamSize == 0 || k <= 0) {
        return NULL;
    }
    
    if (k >= streamSize) {
        int* result = (int*)malloc(streamSize * sizeof(int));
        for (int i = 0; i < streamSize; i++) {
            result[i] = stream[i];
        }
        *returnSize = streamSize;
        return result;
    }
    
    // Initialize reservoir with first k items
    int* reservoir = (int*)malloc(k * sizeof(int));
    for (int i = 0; i < k; i++) {
        reservoir[i] = stream[i];
    }
    
    // Process remaining items
    for (int i = k; i < streamSize; i++) {
        // Generate "random" index using deterministic method
        int sum = 0;
        for (int j = 0; j <= i; j++) {
            sum += stream[j];
        }
        int seed = (sum * 31 + i * 17) % (i + 1);
        
        // If random index < k, replace item in reservoir
        if (seed < k) {
            reservoir[seed] = stream[i];
        }
    }
    
    *returnSize = k;
    return reservoir;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int stream[100];
    int streamSize = 0;
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token) {
            stream[streamSize++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    int k;
    scanf("%d", &k);
    
    int returnSize;
    int* result = solution(stream, streamSize, k, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all n stream elements

✓ Linear Growth

Space Complexity

O(k)

Reservoir array stores exactly k items

⚡ Linearithmic Space

28.5K 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

Reservoir Sampling - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Reservoir Sampling — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler