Smallest Number in Infinite Set - Practice Coding Problems

Smallest Number in Infinite Set - Problem

You are tasked with implementing a data structure that manages an infinite set of positive integers [1, 2, 3, 4, 5, ...]. The challenge is to efficiently handle two key operations:

Remove the smallest number from the set and return it
Add a number back to the set if it's not already present

This is a classic design problem that tests your ability to choose the right data structures for optimal performance. Think about how you would maintain the "smallest available number" efficiently while supporting dynamic additions and removals.

Implement the SmallestInfiniteSet class:

SmallestInfiniteSet() - Initialize the object to contain all positive integers
int popSmallest() - Remove and return the smallest integer in the set
void addBack(int num) - Add a positive integer back into the set (only if not already present)

Key insight: You don't need to store all infinite numbers explicitly!

Input & Output

basic_operations.py — Python

$ Input: ["SmallestInfiniteSet", "addBack", "popSmallest", "popSmallest", "popSmallest", "addBack", "popSmallest", "popSmallest", "popSmallest"] [[], [2], [], [], [], [1], [], [], []]

› Output: [null, null, 1, 2, 3, null, 1, 4, 5]

💡 Note: Initialize the set with all positive integers. AddBack(2) does nothing since 2 is already in set. PopSmallest() returns 1,2,3 in sequence. AddBack(1) adds 1 back since it was removed. Next popSmallest() returns 1, then 4,5 as the sequence continues.

multiple_addbacks.py — Python

$ Input: ["SmallestInfiniteSet", "popSmallest", "popSmallest", "addBack", "addBack", "popSmallest", "popSmallest"] [[], [], [], [1], [2], [], []]

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

💡 Note: Pop 1 and 2, then add both back. The next pops return 1 and 2 again since they're the smallest available numbers.

no_duplicate_addback.py — Python

$ Input: ["SmallestInfiniteSet", "addBack", "addBack", "popSmallest", "addBack", "popSmallest"] [[], [1], [1], [], [1], []]

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

💡 Note: Multiple addBack(1) calls when 1 is already in the set have no effect. First pop returns 1, addBack(1) adds it once, second pop returns 2.

Constraints

1 ≤ num ≤ 1000
At most 1000 calls will be made in total to popSmallest and addBack
All numbers are positive integers

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Books 1,2,3,4,5... are all available. Next book to give out: #1

Checkout Books

Give out books 1,2,3 in order. Next book to give out: #4

Return Book

Book #2 is returned. Add it to our 'returned books' pile

Next Checkout

Compare: returned book #2 vs next new book #4. Give out #2 (smaller)

Key Takeaway

🎯 Key Insight: We only need to track returned books (min-heap) and the next new book counter. This handles infinite sets efficiently!

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 Apple 12

The optimal approach uses a min-heap to store returned numbers and a counter to track the next new number. This achieves O(log n) time complexity for both operations while using minimal space. The key insight is that we only need to store numbers that were previously given out and returned, not the entire infinite set.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal: Min-Heap + Counter	O(log n)	O(m)	Use a min-heap for returned numbers and a counter for new numbers
Brute Force (Array Tracking)	O(n)	O(n)	Use a boolean array to track which numbers are available

Optimal: Min-Heap + Counter — Algorithm Steps

Initialize counter to 1 (next new number to give out) and empty min-heap
For popSmallest(): if heap is empty or heap's min >= counter, return counter++; otherwise return heap.pop()
For addBack(): if num < counter (meaning it was previously given out), add to heap

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Counter=1, Empty heap

Pop Operations

Return counter values 1,2,3... incrementing each time

AddBack(2)

2 < current(4), so add 2 to heap

Next Pop

Heap min (2) < current (4), so return 2 from heap

Code -

solution.c — C

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

typedef struct {
    int* heap;
    int size;
    int capacity;
    int current;
    bool* addedBack;
    int maxNum;
} SmallestInfiniteSet;

void heapifyUp(int* heap, int index) {
    int parent = (index - 1) / 2;
    if (parent >= 0 && heap[parent] > heap[index]) {
        int temp = heap[parent];
        heap[parent] = heap[index];
        heap[index] = temp;
        heapifyUp(heap, parent);
    }
}

void heapifyDown(int* heap, int size, int index) {
    int left = 2 * index + 1;
    int right = 2 * index + 2;
    int smallest = index;
    
    if (left < size && heap[left] < heap[smallest])
        smallest = left;
    if (right < size && heap[right] < heap[smallest])
        smallest = right;
    
    if (smallest != index) {
        int temp = heap[index];
        heap[index] = heap[smallest];
        heap[smallest] = temp;
        heapifyDown(heap, size, smallest);
    }
}

SmallestInfiniteSet* smallestInfiniteSetCreate() {
    SmallestInfiniteSet* obj = malloc(sizeof(SmallestInfiniteSet));
    obj->heap = malloc(1000 * sizeof(int));
    obj->size = 0;
    obj->capacity = 1000;
    obj->current = 1;
    obj->maxNum = 1000;
    obj->addedBack = calloc(obj->maxNum + 1, sizeof(bool));
    return obj;
}

int smallestInfiniteSetPopSmallest(SmallestInfiniteSet* obj) {
    if (obj->size > 0 && obj->heap[0] < obj->current) {
        int smallest = obj->heap[0];
        obj->heap[0] = obj->heap[obj->size - 1];
        obj->size--;
        if (obj->size > 0) heapifyDown(obj->heap, obj->size, 0);
        if (smallest <= obj->maxNum) obj->addedBack[smallest] = false;
        return smallest;
    } else {
        return obj->current++;
    }
}

void smallestInfiniteSetAddBack(SmallestInfiniteSet* obj, int num) {
    if (num < obj->current && (num > obj->maxNum || !obj->addedBack[num])) {
        if (obj->size < obj->capacity) {
            obj->heap[obj->size] = num;
            heapifyUp(obj->heap, obj->size);
            obj->size++;
            if (num <= obj->maxNum) obj->addedBack[num] = true;
        }
    }
}

void smallestInfiniteSetFree(SmallestInfiniteSet* obj) {
    free(obj->heap);
    free(obj->addedBack);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Both operations are O(log n) where n is the number of returned elements due to heap operations

⚡ Linearithmic

Space Complexity

O(m)

Only stores m returned numbers in the heap, not the entire infinite set

✓ Linear Space

23.5K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimal: Min-Heap + Counter — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler