Design a Number Container System - Practice Coding Problems

Design a Number Container System - Problem

Design a Number Container System

You need to design a smart container system that can efficiently manage numbers at specific indices. Think of it as a dynamic array where you can:

🔧 Insert or Replace: Place any number at any index, replacing existing values if needed
🔍 Quick Lookup: Find the smallest index that contains a specific number

Your system should support two main operations:

change(index, number) - Updates the container at the given index with the new number
find(number) - Returns the smallest index containing that number, or -1 if not found

The challenge is to make both operations as efficient as possible, especially when dealing with frequent updates and lookups.

Example:

NumberContainers nc = new NumberContainers();
nc.change(1, 10);  // Container[1] = 10
nc.change(2, 20);  // Container[2] = 20
nc.change(3, 10);  // Container[3] = 10
nc.find(10);       // Returns 1 (smallest index with value 10)
nc.change(1, 30);  // Container[1] = 30
nc.find(10);       // Returns 3 (now smallest index with 10)

Input & Output

example_1.py — Basic Operations

$ Input: ["NumberContainers", "find", "change", "change", "find", "change", "find"] [[], [10], [2, 10], [1, 10], [10], [3, 10], [10]]

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

💡 Note: Initially empty, find(10) returns -1. After change(2,10) and change(1,10), find(10) returns 1 (smallest index). After change(3,10), find(10) still returns 1.

example_2.py — Index Updates

$ Input: ["NumberContainers", "change", "change", "change", "find", "change", "find"] [[], [1, 10], [2, 20], [3, 10], [10], [1, 30], [10]]

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

💡 Note: Initially containers: {1:10, 2:20, 3:10}. find(10) returns 1. After changing index 1 to 30, find(10) returns 3.

example_3.py — Edge Case Empty

$ Input: ["NumberContainers", "find", "change", "find", "change", "find"] [[], [1], [1, 10], [1], [1, 20], [10]]

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

💡 Note: find(1) returns -1 initially and after change(1,10). After change(1,20), find(10) returns -1 since 10 no longer exists.

Constraints

1 ≤ index, number ≤ 10⁹
At most 10⁵ calls will be made in total to change and find
Each operation must be handled efficiently

Visualization

Tap to expand

Understanding the Visualization

Book Catalog

Maintain a catalog mapping shelf numbers to books stored there

Location Index

Keep an index mapping each book title to all shelf locations, sorted by shelf number

Quick Updates

When moving a book, update both the catalog and location index

Fast Lookups

To find a book, check the location index for the lowest shelf number

Key Takeaway

🎯 Key Insight: By maintaining both a shelf catalog (index→number) and a book location index (number→min-heap), we can perform both updates and lookups efficiently!

Asked in

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

The optimal solution uses dual hash maps with min-heaps to achieve O(1) change and O(log n) find operations. Key insight: maintain both index→number mapping for updates and number→min-heap mapping for efficient minimum index retrieval, with lazy cleanup of stale entries.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Maps with Min-Heap (Optimal)	O(1) change, O(log n) find	O(n)	Use bidirectional mappings with min-heaps to efficiently track smallest indices
Brute Force (Linear Search)	O(1) change, O(n) find	O(n)	Store numbers in a simple map and scan all indices for each find operation

Hash Maps with Min-Heap (Optimal) — Algorithm Steps

Store index→number mapping for change operations
Store number→min-heap mapping for find operations
On change: update both mappings, add new index to heap
On find: peek min-heap top, clean stale entries lazily
Return minimum valid index or -1 if not found

Visualization

Tap to expand

Step-by-Step Walkthrough

Dual Storage

Maintain index→number map and number→heap map

Heap Operations

Use min-heap to quickly find smallest indices

Lazy Cleanup

Remove stale entries only when needed

Code -

solution.c — C

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

#define MAX_SIZE 1000
#define MAX_NUMBERS 1000

typedef struct {
    int data[MAX_SIZE];
    int size;
} MinHeap;

typedef struct {
    int indices[MAX_SIZE];
    int numbers[MAX_SIZE];
    int size;
    MinHeap heaps[MAX_NUMBERS];
    int heapNumbers[MAX_NUMBERS];
    int heapCount;
} NumberContainers;

void heapPush(MinHeap* heap, int val) {
    heap->data[heap->size] = val;
    int i = heap->size++;
    while (i > 0 && heap->data[(i-1)/2] > heap->data[i]) {
        int temp = heap->data[i];
        heap->data[i] = heap->data[(i-1)/2];
        heap->data[(i-1)/2] = temp;
        i = (i-1)/2;
    }
}

int heapPop(MinHeap* heap) {
    if (heap->size == 0) return -1;
    int result = heap->data[0];
    heap->data[0] = heap->data[--heap->size];
    
    int i = 0;
    while (2*i + 1 < heap->size) {
        int minChild = 2*i + 1;
        if (2*i + 2 < heap->size && heap->data[2*i + 2] < heap->data[minChild]) {
            minChild = 2*i + 2;
        }
        if (heap->data[i] <= heap->data[minChild]) break;
        int temp = heap->data[i];
        heap->data[i] = heap->data[minChild];
        heap->data[minChild] = temp;
        i = minChild;
    }
    return result;
}

NumberContainers* numberContainersCreate() {
    NumberContainers* obj = (NumberContainers*)malloc(sizeof(NumberContainers));
    obj->size = 0;
    obj->heapCount = 0;
    return obj;
}

void numberContainersChange(NumberContainers* obj, int index, int number) {
    // Update or add mapping
    int found = 0;
    for (int i = 0; i < obj->size; i++) {
        if (obj->indices[i] == index) {
            obj->numbers[i] = number;
            found = 1;
            break;
        }
    }
    if (!found) {
        obj->indices[obj->size] = index;
        obj->numbers[obj->size] = number;
        obj->size++;
    }
    
    // Add to heap
    MinHeap* heap = NULL;
    for (int i = 0; i < obj->heapCount; i++) {
        if (obj->heapNumbers[i] == number) {
            heap = &obj->heaps[i];
            break;
        }
    }
    if (!heap && obj->heapCount < MAX_NUMBERS) {
        heap = &obj->heaps[obj->heapCount];
        heap->size = 0;
        obj->heapNumbers[obj->heapCount] = number;
        obj->heapCount++;
    }
    if (heap) {
        heapPush(heap, index);
    }
}

int numberContainersFind(NumberContainers* obj, int number) {
    MinHeap* heap = NULL;
    for (int i = 0; i < obj->heapCount; i++) {
        if (obj->heapNumbers[i] == number) {
            heap = &obj->heaps[i];
            break;
        }
    }
    if (!heap) return -1;
    
    while (heap->size > 0) {
        int minIndex = heap->data[0];
        // Check if still valid
        int valid = 0;
        for (int i = 0; i < obj->size; i++) {
            if (obj->indices[i] == minIndex && obj->numbers[i] == number) {
                valid = 1;
                break;
            }
        }
        if (valid) return minIndex;
        heapPop(heap);
    }
    
    return -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(1) change, O(log n) find

Change is constant hash map update and heap insertion. Find is logarithmic heap operations with lazy cleanup

⚡ Linearithmic

Space Complexity

O(n)

Space for two hash maps plus min-heaps storing indices

⚡ Linearithmic Space

42.5K Views

High Frequency

~25 min Avg. Time

1.3K 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 Maps with Min-Heap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler