I took the array of list approach. rbt would have been more optimal on worst case

design_hashset.cpp

//  using chaining
class MyHashSet {
    vector<list<int> *> hashSet;
    const int CAP = 1000;
public:
    /** Initialize your data structure here. */
    // initializing with nullptr allows you not to create unnecessary space until needed i.e. on add
    MyHashSet() {
        hashSet = vector<list<int> *>(CAP, nullptr); 
    }
    
    void add(int key) {
        int hash = getHash(key);
        if(hashSet[hash] == nullptr)
            hashSet[hash] = new list<int>();
        
        if(contains(key))
            return;
        

        hashSet[hash]->push_back(key);
    }
    
    void remove(int key) {
          if(!contains(key)) return;
        
        int hash = getHash(key);

        hashSet[hash]->remove(key);
    }
    
     int getHash(int key)
    {
        return key%capacity;
    }
    
     /** Returns true if this set contains the specified element */
    // each chain will be max size 10 since there would be max 10k operations
    bool contains(int key) {
        int hash = getHash(key);
        
        if(hashSet[hash] == nullptr) return false;

        for(auto &temp : *hashSet[hash])
        {
            if(temp == key) return true;
        }
        
        return false;
        
    }
};

/**
 * Your MyHashSet object will be instantiated and called as such:
 * MyHashSet* obj = new MyHashSet();
 * obj->add(key);
 * obj->remove(key);
 * bool param_3 = obj->contains(key);
 */