2349. Design a Number Container System LeetCode Solution

Last updated: February 27, 2025

In this guide, you will get 2349. Design a Number Container System LeetCode Solution with the best time and space complexity. The solution to Design a Number Container System problem is provided in various programming languages like C++, Java, and Python. This will be helpful for you if you are preparing for placements, hackathons, interviews, or practice purposes. The solutions provided here are very easy to follow and include detailed explanations.

Problem Statement
Complexity Analysis
Design a Number Container System solution in C++
Design a Number Container System solution in Java
Design a Number Container System solution in Python
Additional Resources

2349. Design a Number Container System LeetCode Solution image

Problem Statement of Design a Number Container System

Design a number container system that can do the following:

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.

Example 1:

Input
[“NumberContainers”, “find”, “change”, “change”, “change”, “change”, “find”, “change”, “find”]
[[], [10], [2, 10], [1, 10], [3, 10], [5, 10], [10], [1, 20], [10]]
Output
[null, -1, null, null, null, null, 1, null, 2]

Explanation
NumberContainers nc = new NumberContainers();
nc.find(10); // There is no index that is filled with number 10. Therefore, we return -1.
nc.change(2, 10); // Your container at index 2 will be filled with number 10.
nc.change(1, 10); // Your container at index 1 will be filled with number 10.
nc.change(3, 10); // Your container at index 3 will be filled with number 10.
nc.change(5, 10); // Your container at index 5 will be filled with number 10.
nc.find(10); // Number 10 is at the indices 1, 2, 3, and 5. Since the smallest index that is filled with 10 is 1, we return 1.
nc.change(1, 20); // Your container at index 1 will be filled with number 20. Note that index 1 was filled with 10 and then replaced with 20.
nc.find(10); // Number 10 is at the indices 2, 3, and 5. The smallest index that is filled with 10 is 2. Therefore, we return 2.

Constraints:

1 <= index, number <= 109
At most 105 calls will be made in total to change and find.

Complexity Analysis

Time Complexity: O(\log n)
Space Complexity: O(n)

2349. Design a Number Container System LeetCode Solution in C++

class NumberContainers {
 public:
  void change(int index, int number) {
    const auto it = indexToNumber.find(index);
    if (it != indexToNumber.cend()) {
      const int originalNumber = it->second;
      auto& indices = numberToIndices[originalNumber];
      indices.erase(index);
      if (indices.empty())
        numberToIndices.erase(originalNumber);
    }
    numberToIndices[number].insert(index);
  }

  int find(int number) {
    const auto it = numberToIndices.find(number);
    if (it == numberToIndices.cend())
      return -1;
    const auto& indices = it->second;
    return *indices.begin();
  }

 private:
  unordered_map<int, int> indexToNumber;
  unordered_map<int, set<int>> numberToIndices;
};
/* code provided by PROGIEZ */

2349. Design a Number Container System LeetCode Solution in Java

class NumberContainers {
  public void change(int index, int number) {
    if (indexToNumbers.containsKey(index)) {
      final int originalNumber = indexToNumbers.get(index);
      numberToIndices.get(originalNumber).remove(index);
      if (numberToIndices.get(originalNumber).isEmpty())
        numberToIndices.remove(originalNumber);
    }
    indexToNumbers.put(index, number);
    numberToIndices.putIfAbsent(number, new TreeSet<>());
    numberToIndices.get(number).add(index);
  }

  public int find(int number) {
    if (numberToIndices.containsKey(number))
      return numberToIndices.get(number).first();
    return -1;
  }

  private Map<Integer, TreeSet<Integer>> numberToIndices = new HashMap<>();
  private Map<Integer, Integer> indexToNumbers = new HashMap<>();
}
// code provided by PROGIEZ

2349. Design a Number Container System LeetCode Solution in Python

from sortedcontainers import SortedSet


class NumberContainers:
  def __init__(self):
    self.numberToIndices = collections.defaultdict(SortedSet)
    self.indexToNumber = {}

  def change(self, index: int, number: int) -> None:
    if index in self.indexToNumber:
      originalNumber = self.indexToNumber[index]
      self.numberToIndices[originalNumber].remove(index)
      if len(self.numberToIndices[originalNumber]) == 0:
        del self.numberToIndices[originalNumber]
    self.indexToNumber[index] = number
    self.numberToIndices[number].add(index)

  def find(self, number: int) -> int:
    if number in self.numberToIndices:
      return self.numberToIndices[number][0]
    return -1
 # code by PROGIEZ

Additional Resources

Happy Coding! Keep following PROGIEZ for more updates and solutions.

Table of Contents