class HashTable:
    def __init__(self, size=11):
        self.size = size
        self.slots = [None] * self.size
        self.data = [None] * self.size

    def put(self, key, value):
        if isinstance(key, str):
            newkey = ord(key)
        else:
            newkey = key
        hashvalue = self.hashfunction(newkey, self.size)
        if self.slots[hashvalue] == None:
            self.slots[hashvalue] = key
            self.data[hashvalue] = value
        else:
            if self.slots[hashvalue] == key:
                self.data[hashvalue] = value
            else:
                nextslot = self.rehash(hashvalue, self.size)
                while self.slots[nextslot] != None and self.slots[nextslot] != key:
                    nextslot = self.rehash(nextslot, self.size)
                if self.slots[nextslot] == None:
                    self.slots[nextslot] = key
                    self.data[nextslot] = value
                else:
                    self.data[nextslot] = value

    def hashfunction(self, key, size):
        return key % size

    def rehash(self, oldhash, size):
        return (oldhash + 1) % size

    def get(self, key):
        if isinstance(key, str):
            newkey = ord(key)
        else:
            newkey = key
        startslot = self.hashfunction(newkey, self.size)
        pos = startslot
        while 1:
            if self.slots[pos] == key:
                return self.data[pos]
            else:
                pos = self.rehash(pos, self.size)
                if pos == startslot:
                    raise KeyError(f'{key} not found')

    def __getitem__(self, key):
        return self.get(key)

    def __setitem__(self, key, value):
        self.put(key, value)

    def len(self):
        count = 0
        for i in self.slots:
            if i != None:
                count += 1
        return count

    def __delitem__(self, key):
        if isinstance(key, str):
            newkey = ord(key)
        else:
            newkey = key
        startslot = self.hashfunction(newkey, self.size)
        pos = startslot
        while 1:
            if self.slots[pos] == newkey:
                self.slots[pos] = None
                self.data[pos] = None
                break
            else:
                pos = self.rehash(pos, self.size)
                if pos == startslot:
                    raise KeyError(f'{key} not found')

    def __contains__(self, key):
        if isinstance(key, str):
            newkey = ord(key)
        else:
            newkey = key
        startslot = self.hashfunction(newkey, self.size)
        pos = startslot
        while 1:
            if self.slots[pos] == newkey:
                return True
            else:
                pos = self.rehash(pos, self.size)
                if pos == startslot:
                    return False

    # def __iter__(self):
    #     return iter(self.slots)

    def __repr__(self):
        s = '{'
        for i in self.slots:
            if i is not None:
                value = self.data[self.slots.index(i)]
                if isinstance(i, str):
                    if isinstance(value, str):
                        s = s + f"'{i}' : '{value}' , "
                    else:
                        s = s + f"'{i}' : {value} , "
                else:
                    if isinstance(value, str):
                        s = s + f"{i} : '{value}' , "
                    else:
                        s = s + f"{i} : {value} , "

        s = s.rstrip(', ')
        s = s + '}'
        return s