# Solving Leetcode Interviews in Seconds with AI: Design a Number Container System


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2349" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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.  

	# Explanation
	Here's an efficient implementation of the NumberContainers class in Python, addressing the problem constraints and optimizing for performance.

*   **Key Approach:**
    *   Use a dictionary (`index_map`) to store the number at each index. This allows for O(1) `change` operations (insert/replace).
    *   Use a dictionary (`number_map`) to store a sorted set of indices for each number. This facilitates finding the smallest index for a given number efficiently. We use a sorted set to automatically keep indices sorted and ensure the smallest index can be retrieved quickly.

*   **Complexity:**
    *   Runtime Complexity: `change`: O(log n) for updating the sorted set, `find`: O(1) on average.
    *   Storage Complexity: O(N) where N is the number of unique indices used.

	
	# Code
	```python
	from sortedcontainers import SortedSet

class NumberContainers:
    def __init__(self):
        self.index_map = {}  # index: number
        self.number_map = {}  # number: SortedSet of indices

    def change(self, index: int, number: int) -> None:
        if index in self.index_map:
            old_number = self.index_map[index]
            self.number_map[old_number].remove(index)
            if not self.number_map[old_number]:
                del self.number_map[old_number]

        self.index_map[index] = number
        if number not in self.number_map:
            self.number_map[number] = SortedSet()
        self.number_map[number].add(index)

    def find(self, number: int) -> int:
        if number in self.number_map:
            return self.number_map[number][0]
        else:
            return -1
	```