Design a Number Container System

Design a Number Container System - Problem

Design a number container system that can perform the following operations:

Insert or Replace a number at the given index in the system.
Return the smallest index for the given number in the system.

Implement the NumberContainers class:

NumberContainers() Initializes the number container system.
void change(int index, int number) Fills the container at index with the number. If there is already a number at that index, replace it.
int find(int number) Returns the smallest index for the given number, or -1 if there is no index that is filled by number in the system.

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["NumberContainers", "change", "find", "change", "find", "find"], values = [[], [1, 10], [1], [2, 20], [1], [3]]

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

💡 Note: NumberContainers nc = new NumberContainers(); nc.change(1, 10); // container[1] = 10. nc.find(1) returns -1 (number 1 not found); nc.change(2, 20); // container[2] = 20. nc.find(1) returns -1 (number 1 still not found); nc.find(3) returns -1 (number 3 not found).

Example 2 — Multiple Indices Same Number

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

› Output: [1, 1]

💡 Note: Multiple indices can have same number. System returns smallest index: indices 1 and 3 both have 10, so find(10) returns 1. After adding index 2 with 10, find(10) still returns 1 (smallest).

Example 3 — Replace Existing Value

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

› Output: [1, -1]

💡 Note: Initially container[1] = 10, so find(10) returns 1. Then change(1, 20) replaces the value, so find(10) returns -1 (no longer exists).

Constraints

1 ≤ index, number ≤ 10⁹
At most 10⁵ calls to change and find

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to maintain two hash maps: one for index→number lookups and another for number→sorted indices. The optimal approach uses min-heaps to efficiently find the smallest index for any number. Best approach: Two Hash Maps with Min-Heap. Time: O(log k) per operation, Space: O(n + m).

Common Approaches

✓ Single Map with Linear Search

⏱️ Time: O(1) change, O(n) find Space: O(n)

Use a single hash map to store index→number mappings. For change operations, simply update the map. For find operations, iterate through all entries to find the smallest index with the target number.

Two Hash Maps with Min-Heap

⏱️ Time: O(log k) change, O(log k) find Space: O(n + m)

Maintain two data structures: a hash map for index→number lookups and another hash map where each number maps to a min-heap of indices. This allows O(1) change operations and O(log k) find operations where k is the number of indices with the target number.

Single Map with Linear Search — Algorithm Steps

Store index→number mappings in hash map
For change: update map[index] = number
For find: iterate all entries, find min index with target number

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Mappings

Maintain index→number map

Linear Search

Check every entry for target number

Find Minimum

Return smallest index found

Code -

solution.c — C

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

#define MAX_ENTRIES 100000

typedef struct {
    int index;
    int number;
} IndexNumberPair;

typedef struct {
    int number;
    int min_index;
} NumberIndexPair;

static IndexNumberPair index_to_number[MAX_ENTRIES];
static NumberIndexPair number_to_min_index[MAX_ENTRIES];
static int index_count = 0;
static int number_count = 0;

void numberContainersInit() {
    index_count = 0;
    number_count = 0;
}

void change(int index, int number) {
    // Check if index already exists and update
    for (int i = 0; i < index_count; i++) {
        if (index_to_number[i].index == index) {
            int old_number = index_to_number[i].number;
            index_to_number[i].number = number;
            
            // Update min index for old number
            int min_idx = INT_MAX;
            for (int j = 0; j < index_count; j++) {
                if (index_to_number[j].number == old_number) {
                    if (index_to_number[j].index < min_idx) {
                        min_idx = index_to_number[j].index;
                    }
                }
            }
            
            // Update or remove old number entry
            for (int j = 0; j < number_count; j++) {
                if (number_to_min_index[j].number == old_number) {
                    if (min_idx == INT_MAX) {
                        // Remove entry
                        for (int k = j; k < number_count - 1; k++) {
                            number_to_min_index[k] = number_to_min_index[k + 1];
                        }
                        number_count--;
                    } else {
                        number_to_min_index[j].min_index = min_idx;
                    }
                    break;
                }
            }
            
            // Update min index for new number
            min_idx = INT_MAX;
            for (int j = 0; j < index_count; j++) {
                if (index_to_number[j].number == number) {
                    if (index_to_number[j].index < min_idx) {
                        min_idx = index_to_number[j].index;
                    }
                }
            }
            
            // Update or add new number entry
            int found = 0;
            for (int j = 0; j < number_count; j++) {
                if (number_to_min_index[j].number == number) {
                    number_to_min_index[j].min_index = min_idx;
                    found = 1;
                    break;
                }
            }
            if (!found) {
                number_to_min_index[number_count].number = number;
                number_to_min_index[number_count].min_index = min_idx;
                number_count++;
            }
            return;
        }
    }
    
    // Add new index-number pair
    index_to_number[index_count].index = index;
    index_to_number[index_count].number = number;
    index_count++;
    
    // Update min index for the number
    int min_idx = index;
    for (int i = 0; i < index_count; i++) {
        if (index_to_number[i].number == number && index_to_number[i].index < min_idx) {
            min_idx = index_to_number[i].index;
        }
    }
    
    // Update or add number entry
    int found = 0;
    for (int i = 0; i < number_count; i++) {
        if (number_to_min_index[i].number == number) {
            number_to_min_index[i].min_index = min_idx;
            found = 1;
            break;
        }
    }
    if (!found) {
        number_to_min_index[number_count].number = number;
        number_to_min_index[number_count].min_index = min_idx;
        number_count++;
    }
}

int find(int number) {
    for (int i = 0; i < number_count; i++) {
        if (number_to_min_index[i].number == number) {
            return number_to_min_index[i].min_index;
        }
    }
    return -1;
}

int parseInt(const char* str, int* pos) {
    while (str[*pos] == ' ' || str[*pos] == '[' || str[*pos] == ',' || str[*pos] == ']') (*pos)++;
    if (str[*pos] == '\0' || str[*pos] == '\n') return 0;
    
    int sign = 1;
    if (str[*pos] == '-') {
        sign = -1;
        (*pos)++;
    }
    
    int num = 0;
    while (str[*pos] >= '0' && str[*pos] <= '9') {
        num = num * 10 + (str[*pos] - '0');
        (*pos)++;
    }
    return sign * num;
}

int main() {
    char operations[2000], values[2000];
    fgets(operations, sizeof(operations), stdin);
    fgets(values, sizeof(values), stdin);
    
    numberContainersInit();
    
    int op_pos = 0, val_pos = 0;
    int first_result = 1;
    printf("[");
    
    // Skip first operation (constructor)
    while (operations[op_pos] && operations[op_pos] != '"') op_pos++;
    if (operations[op_pos] == '"') {
        op_pos++;
        while (operations[op_pos] && operations[op_pos] != '"') op_pos++;
        op_pos++;
    }
    
    // Skip first value array
    while (values[val_pos] && values[val_pos] != ']') val_pos++;
    val_pos++;
    
    while (operations[op_pos]) {
        // Find next operation
        while (operations[op_pos] && operations[op_pos] != '"') op_pos++;
        if (!operations[op_pos]) break;
        op_pos++;
        
        char op_name[20] = {0};
        int op_idx = 0;
        while (operations[op_pos] && operations[op_pos] != '"' && op_idx < 19) {
            op_name[op_idx++] = operations[op_pos++];
        }
        op_pos++;
        
        // Find corresponding values
        while (values[val_pos] && values[val_pos] != '[') val_pos++;
        val_pos++;
        
        if (strcmp(op_name, "change") == 0) {
            int index = parseInt(values, &val_pos);
            int number = parseInt(values, &val_pos);
            change(index, number);
        } else if (strcmp(op_name, "find") == 0) {
            int number = parseInt(values, &val_pos);
            int result = find(number);
            if (!first_result) printf(",");
            printf("%d", result);
            first_result = 0;
        }
        
        // Skip to end of value array
        while (values[val_pos] && values[val_pos] != ']') val_pos++;
        val_pos++;
    }
    
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1) change, O(n) find

Change is direct map update, find requires scanning all n entries

⚡ Linearithmic

Space Complexity

O(n)

Single hash map storing up to n index→number pairs

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~25 min Avg. Time

890 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

Single Map with Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler