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.


&nbsp;
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.


&nbsp;
Constraints:


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


class NumberContainers:
    def __init__(self):
        self.numbersByIndex = {}
        self.numberIndexes = defaultdict(set)
        self.numberIndexesHeap = defaultdict(list)

    def change(self, index: int, number: int) -> None:
        if index in self.numbersByIndex:
            if number != self.numbersByIndex[index]:
                self.numberIndexes[self.numbersByIndex[index]].remove(index)
                self.numbersByIndex[index] = number
                self.numberIndexes[number].add(index)
                heappush(self.numberIndexesHeap[number], index)
        else:
            self.numbersByIndex[index] = number
            self.numberIndexes[number].add(index)
            heappush(self.numberIndexesHeap[number], index)

    def find(self, number: int) -> int:
        while self.numberIndexesHeap[number] and self.numberIndexesHeap[number][0] not in self.numberIndexes[number]:
                heappop(self.numberIndexesHeap[number])  # make sure the smallest index in heap is still an index for number
        return self.numberIndexesHeap[number][0] if self.numberIndexesHeap[number] else -1
class NumberContainers {
    
    Map<Integer,TreeSet<Integer>> map;
    Map<Integer,Integer> m;
    public NumberContainers() {
        map=new HashMap<>();
        m=new HashMap<>();
        
    }
    public void change(int index, int number) {
        m.put(index,number);
        if(!map.containsKey(number)) map.put(number,new TreeSet<>());
        map.get(number).add(index);
    }
    
    public int find(int number) {
        if(!map.containsKey(number)) return -1;
        for(Integer a:map.get(number)){
            if(m.get(a)==number) return a;
        }
        return -1;
    }
}
class NumberContainers {
public:
    map<int, int> indexToNumber; // stores number corresponding to an index.
    map<int, set<int>>numberToIndex; // stores all the indexes corresponding to a number.
    NumberContainers() {}

    void change(int index, int number) {

        if (!indexToNumber.count(index)) { // if there is no number at the given index.
            numberToIndex[number].insert(index); // store index corresponding to the given number
            indexToNumber[index] = number; // store number corresponding to the index.
        }
        else { // Update both map.

            int num = indexToNumber[index]; // number at given index currently.

            // remove the index
            numberToIndex[num].erase(index);
            if (numberToIndex[num].empty()) numberToIndex.erase(num);

            // insert the new number at the given index and store the index corresponding to that number.
            numberToIndex[number].insert(index);
            indexToNumber[index] = number;
        }
    }

    int find(int number) {
        if (!numberToIndex.count(number)) return -1;
        // returning first element in the set as it will be the smallest index always.
        return *numberToIndex[number].begin();
    }
};
var NumberContainers = function() {
    this.obj = {}
    this.global = {}
};

NumberContainers.prototype.change = function(index, number) {

    if(this.global[index])
        {
            for(var key in this.obj)
            {
               let ind = this.obj[key].indexOf(index)
                if(ind != -1)
                    {
                         this.obj[key].splice(ind, 1);
                        if(this.obj[number])
                            this.obj[number].push(index);
                        else
                            this.obj[number] = [index];

                        this.global[index]=1;
                        return;
                    }
            }
        }

    if(this.obj[number])
        this.obj[number].push(index);
    else
        this.obj[number] = [index];
    this.global[index]=1;
};

NumberContainers.prototype.find = function(number) {
    if(this.obj[number])
        {
            if(this.obj[number].length == 0)
                return -1
            else
                return Math.min(...this.obj[number])
        }
    return -1;
};
Design a Number Container System