Smallest Number in Infinite Set

Smallest Number in Infinite Set - Problem

You have a set which contains all positive integers [1, 2, 3, 4, 5, ...].

Implement the SmallestInfiniteSet class:

SmallestInfiniteSet() Initializes the SmallestInfiniteSet object to contain all positive integers.
int popSmallest() Removes and returns the smallest integer contained in the infinite set.
void addBack(int num) Adds a positive integer num back into the infinite set, if it is not already in the infinite set.

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["SmallestInfiniteSet", "popSmallest", "addBack", "popSmallest"], values = [[], [], [1], []]

› Output: [null, 1, null, 1]

💡 Note: Initialize set with all positive integers. popSmallest() returns 1. addBack(1) puts 1 back. popSmallest() returns 1 again.

Example 2 — Multiple Pops

$ Input: operations = ["SmallestInfiniteSet", "popSmallest", "popSmallest", "addBack", "popSmallest"], values = [[], [], [], [1], []]

› Output: [null, 1, 2, null, 1]

💡 Note: Pop 1, then pop 2. Add 1 back. Next pop returns 1 (smallest available).

Example 3 — No Duplicate Adds

$ Input: operations = ["SmallestInfiniteSet", "addBack", "popSmallest"], values = [[], [1], []]

› Output: [null, null, 1]

💡 Note: Adding 1 when it's already in set has no effect. popSmallest() still returns 1.

Constraints

1 ≤ num ≤ 1000
At most 1000 calls will be made in total to popSmallest and addBack.

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 Apple 25 M Microsoft 31

The key insight is to split the infinite set into two parts: a min-heap for numbers that were popped and added back, and a counter for the next new number to issue. This avoids storing all infinite numbers while maintaining O(log n) performance. Best approach uses Min-Heap + Counter. Time: O(log n), Space: O(n).

Common Approaches

✓ Brute Force with Set Storage

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

Keep a set containing all available numbers. For popSmallest, iterate through numbers 1, 2, 3... until finding one in the set. Remove it and return. For addBack, simply add to the set if not present.

Min-Heap with Counter

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

Maintain a min-heap containing numbers that were popped and added back. Also keep a counter for the next new number to pop. popSmallest returns from heap if available, otherwise returns and increments counter.

Brute Force with Set Storage — Algorithm Steps

Store all available numbers in a set
For popSmallest: scan from 1 upward to find first available
For addBack: add number to set if not already present

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set contains all numbers 1, 2, 3, 4, 5...

PopSmallest

Scan from 1: check if 1 exists, return and remove it

AddBack

Add number back to the available set

Code -

solution.c — C

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

static bool removed[100001];
static int removedSize = 0;

typedef struct {
    int dummy;
} SmallestInfiniteSet;

SmallestInfiniteSet* smallestInfiniteSetCreate() {
    SmallestInfiniteSet* obj = (SmallestInfiniteSet*)malloc(sizeof(SmallestInfiniteSet));
    memset(removed, false, sizeof(removed));
    removedSize = 0;
    return obj;
}

int smallestInfiniteSetPopSmallest(SmallestInfiniteSet* obj) {
    int current = 1;
    while (current <= 100000 && removed[current]) {
        current++;
    }
    removed[current] = true;
    if (current > removedSize) removedSize = current;
    return current;
}

void smallestInfiniteSetAddBack(SmallestInfiniteSet* obj, int num) {
    if (num <= 100000) {
        removed[num] = false;
    }
}

void smallestInfiniteSetFree(SmallestInfiniteSet* obj) {
    free(obj);
}

static int results[1000];
static char operations[1000][30];
static int values[1000];

int* solution(int operationsSize, int valuesSize, int* returnSize) {
    SmallestInfiniteSet* obj = smallestInfiniteSetCreate();
    results[0] = -1;
    int idx = 1;
    for (int i = 1; i < operationsSize; i++) {
        if (strcmp(operations[i], "popSmallest") == 0) {
            results[idx] = smallestInfiniteSetPopSmallest(obj);
        } else {
            smallestInfiniteSetAddBack(obj, values[i]);
            results[idx] = -1;
        }
        idx++;
    }
    smallestInfiniteSetFree(obj);
    *returnSize = idx;
    return results;
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    // Parse operations
    int opCount = 0;
    int len1 = strlen(line1);
    line1[len1-1] = 0; // Remove ]
    char* ptr = line1 + 1; // Skip [
    char* token = ptr;
    bool inQuote = false;
    int start = 0;
    
    for (int i = 0; ptr[i]; i++) {
        if (ptr[i] == '"') {
            if (!inQuote) {
                inQuote = true;
                start = i + 1;
            } else {
                inQuote = false;
                int opLen = i - start;
                strncpy(operations[opCount], ptr + start, opLen);
                operations[opCount][opLen] = 0;
                opCount++;
            }
        }
    }
    
    // Parse values
    int valCount = 0;
    int len2 = strlen(line2);
    line2[len2-1] = 0; // Remove ]
    ptr = line2 + 1; // Skip [
    
    for (int i = 0; ptr[i]; i++) {
        if (ptr[i] == '[') {
            if (ptr[i+1] == ']') {
                values[valCount] = 0;
                valCount++;
                i++; // Skip ]
            } else {
                // Find number
                i++; // Skip [
                int num = 0;
                while (ptr[i] >= '0' && ptr[i] <= '9') {
                    num = num * 10 + (ptr[i] - '0');
                    i++;
                }
                values[valCount] = num;
                valCount++;
            }
        }
    }
    
    int returnSize;
    int* result = solution(opCount, valCount, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        if (result[i] == -1) printf("null");
        else printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

popSmallest scans from 1 up to current minimum, which can be O(n) operations

✓ Linear Growth

Space Complexity

O(n)

Set stores all available numbers, growing with each operation

⚡ Linearithmic Space

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

Brute Force with Set Storage — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler