Added Workshop/hashmap and Workshop/inventory

Author: MitkoVtori

OOP/D.Workshop/# TODO.txt

@@ -0,0 +1,88 @@
+class HashTable:
+
+    def __init__(self):
+        self.__max_capacity = 4
+        self.__keys = [None] * self.__max_capacity
+        self.__values = [None] * self.__max_capacity
+
+    def __getitem__(self, key):
+        try:
+            index = self.__keys.index(key)
+            return self.__values[index]
+        except ValueError:
+            raise KeyError(f"\"{key}\" key not found!")
+
+    def __setitem__(self, key, value):
+        if key in self.__keys:
+            index = self.__keys.index(key)
+            self.__values[index] = value
+            return
+
+        if len(self) == self.__max_capacity:
+            self.__resize()
+
+        index = self.__calc_index(key)
+        index = self.__get_index(index)
+
+        self.__keys[index] = key
+        self.__values[index] = value
+
+    def __calc_index(self, key):
+        return sum(ord(c) for c in key) % self.__max_capacity
+
+    def __get_index(self, index):
+        if index == self.__max_capacity:
+            index = 0
+
+        if self.__keys[index] is None:
+            return index
+
+        return self.__get_index(index + 1)
+
+    def __resize(self):
+        self.__keys = self.__keys + [None] * self.__max_capacity
+        self.__values = self.__values + [None] * self.__max_capacity
+        self.__max_capacity *= 2
+
+    def __len__(self):
+        return len([k for k in self.__keys if k is not None])
+
+    def add(self, key, value):
+        self[key] = value
+
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def get_representation(self):
+        print("{", end="")
+
+        for i in range(self.__max_capacity):
+            key = self.__keys[i]
+
+            if key is not None:
+                print(f"{key}: {self.__values[i]},", end=" ")
+
+        print("}")
+
+
+table = HashTable()
+
+table["name"] = "Peter"
+table["name"] = "Dimitar"
+table["age"] = 16
+table["is_pet_owner"] = True
+table["is_driver"] = False
+
+table.add("a", "A")
+
+print(table.get("b", "This is not a valid key"))
+
+table.get_representation()
+
+print(table)
+print(table.get("name"))
+print(table["age"])
+print(len(table))

OOP/D.Workshop/hashmap/hash_table.py

@@ -0,0 +1,300 @@
+class Inventory:
+
+    def __init__(self, *args):
+        self.__inventory = {}
+        self.__negative_indexes = {}
+
+        for index, item in enumerate(args):
+            self.__inventory[index] = item
+
+        for index, item in enumerate(args[::-1]):
+            index -= (1 + index + index)
+            self.__negative_indexes[index] = item
+
+    def __getitem__(self, index):
+        try:
+            if index < 0:
+                return self.__negative_indexes[index]
+            return self.__inventory[index]
+        except KeyError:
+            raise IndexError("Index out of range!")
+
+    def __get_last_index(self):
+        return len(self.__inventory) - 1
+
+    def __append_to_negative_indexes(self, value):
+        new_indexes = {-1: value}
+        for key, value in self.__negative_indexes.items():
+            new_indexes[key-1] = value
+        return new_indexes
+
+    def append(self, value):
+        index = 1 + self.__get_last_index()
+        self.__inventory[index] = value
+        self.__negative_indexes = self.__append_to_negative_indexes(value)
+
+    def extend(self, iterable):
+        for char in iterable:
+            self.append(char)
+
+    def insert(self, index, value):
+        if index < 0:
+            new_indexes = {}
+            for key, v in self.__negative_indexes.items():
+                if key == index:
+                    new_indexes[index] = value
+                if key <= index:
+                    new_indexes[key-1] = v
+                else:
+                    new_indexes[key] = v
+            self.__negative_indexes = new_indexes
+
+            num = 0
+            new_inventory_indexes = {}
+            for value in self.__negative_indexes.values().__reversed__():
+                new_inventory_indexes[num] = value
+                num += 1
+            self.__inventory = new_inventory_indexes
+            return None
+
+        new_indexes = {}
+        for key, v in self.__inventory.items():
+            if key == index:
+                new_indexes[index] = value
+            if key >= index:
+                new_indexes[key+1] = v
+            else:
+                new_indexes[key] = v
+        self.__inventory = new_indexes
+
+        num = -1
+        new_negative_indexes = {}
+        for value in self.__inventory.values().__reversed__():
+            new_negative_indexes[num] = value
+            num -= 1
+        self.__negative_indexes = new_negative_indexes
+
+    def add_first(self, value):
+        return self.insert(0, value)
+
+    def __remove_from_negative_indexes(self, index):
+        length = len(self.__negative_indexes)
+        length -= index
+
+        if length <= 0:
+            raise IndexError("Index out of range!")
+
+        del self.__negative_indexes[-length]
+
+        return self.__update_negative_indexes()
+
+    def __remove_from_inventory(self, index):
+        length = len(self.__inventory)
+        length -= abs(index)
+
+        if length < 0:
+            raise IndexError("Index out of range!")
+
+        del self.__inventory[length]
+
+        return self.__update_inventory_indexes()
+
+    def __update_negative_indexes(self):
+        new_indexes = {}
+        num = -1
+        for key, value in self.__negative_indexes.items():
+            new_indexes[num] = value
+            num -= 1
+
+        return new_indexes
+
+    def __update_inventory_indexes(self):
+        new_indexes = {}
+        num = 0
+        for key, value in self.__inventory.items():
+            key = num
+            new_indexes[key] = value
+            num += 1
+
+        return new_indexes
+
+    def remove(self, index):
+        try:
+            if index < 0:
+                value = self.__negative_indexes[index]
+                del self.__negative_indexes[index]
+                self.__negative_indexes = self.__update_negative_indexes()
+                self.__inventory = self.__remove_from_inventory(index)
+                return value
+
+            value = self.__inventory[index]
+            del self.__inventory[index]
+            self.__inventory = self.__update_inventory_indexes()
+            self.__negative_indexes = self.__remove_from_negative_indexes(index)
+            return value
+
+        except KeyError:
+            raise IndexError("Index out of range!")
+
+    def clear(self):
+        self.__inventory = {}
+        self.__negative_indexes = {}
+
+    def pop(self, index=-1):
+        return self.remove(index)
+
+    def index(self, value):
+        if value in self.__inventory.values():
+            for k, v in self.__inventory.items():
+                if v == value:
+                    return k
+        else:
+            raise ValueError("Value not found!")
+
+    def get(self, index):
+        if index < 0:
+            return self.__negative_indexes[index]
+        return self.__inventory[index]
+
+    def count(self, value):
+        times = 0
+        for v in self.__inventory.values():
+            if v == value:
+                times += 1
+        return times
+
+    def reverse(self):
+        return Inventory(*self.__inventory.values().__reversed__())
+
+    def copy(self):
+        return Inventory(*self.__inventory.values())
+
+    def size(self):
+        return len(self.__inventory)
+
+    @staticmethod
+    def isnum(element):
+        if isinstance(element, int) or isinstance(element, float):
+            return True
+        return False
+
+    @staticmethod
+    def isstring(element):
+        if isinstance(element, str):
+            return True
+        return False
+
+    @staticmethod
+    def isbool(element):
+        if isinstance(element, bool):
+            return True
+        return False
+
+    @staticmethod
+    def islist(element):
+        if isinstance(element, list) or isinstance(element, tuple):
+            return True
+        return False
+
+    @staticmethod
+    def isInventory(obj):
+        if isinstance(obj, Inventory):
+            return True
+        return False
+
+    def sum(self):
+        total_sum = 0
+        for element in self.__inventory.values():
+            if Inventory.isnum(element):
+                total_sum += element
+            elif Inventory.isstring(element):
+                total_sum += len(element)
+            elif Inventory.isbool(element):
+                continue
+            else:
+                raise ValueError(f"{element} cannot be summed!")
+
+        return total_sum
+
+    def __dict__(self):
+        return self.__inventory
+
+#    def test(self):
+#        return self.__inventory
+
+#    def test_2(self):
+#        return self.__negative_indexes
+
+    def __str__(self):
+        return '[' + ', '.join([str(char) if type(char) != str else f"\'{char}\'" for char in self.__inventory.values()]) + ']'
+
+
+inventory = Inventory(1, 2, -6, 3, 4, 5, 6, 7, 8, 9, 10, "Gorge", True, False)
+
+print(inventory) # [1, 2, -6, 3, 4, 5, 6, 7, 8, 9, 10, "Gorge", True, False]
+print(inventory[3]) # 3
+print(inventory[-3]) # Gorge
+print()
+try:
+    print(inventory[:5])
+except:
+    print("Cannot slice")
+print()
+try:
+    print(inventory[1287])
+except:
+    pass
+print()
+inventory.append("Seven")
+print(inventory[-1]) # Seven
+print()
+inventory.extend([[1, 2, 3], [1, 3, 2]])
+print(inventory[-1]) # [1, 3, 2]
+print()
+inventory.insert(3, "8")
+print(inventory) # [1, 2, -6, "8", 3, 4, 5, 6, 7, 8, 9, 10, "Gorge", True, False, "Seven", [1, 2, 3], [1, 3, 2]]
+
+inventory.add_first(0)
+
+print(inventory)
+# print(inventory.test_2())
+
+print(inventory[0]) # 0
+
+inventory.remove(0)
+
+print(inventory)
+# print(inventory.test_2())
+
+print(inventory[0]) # 1
+
+print(inventory.pop()) # [1, 3, 2]
+
+print(inventory)
+# print(inventory.test_2())
+
+print(inventory[-1]) # [1, 2, 3]
+
+print(inventory.index(1)) # 0
+
+print(inventory.get(2)) # -6
+
+print(inventory.count("Gorge")) # 1
+
+inventory = Inventory(3, 2, 1)
+print(inventory.reverse()) # [1, 2, 3]
+print(inventory) # [3, 2, 1]
+
+inventory_copy = inventory.copy()
+print(inventory != inventory_copy) # True
+
+inventory_copy.append(1)
+print(inventory.size()) # 3
+
+inventory = Inventory(1, "23", 4)
+print(inventory.sum()) # 7
+
+print(inventory.__dict__()) # {0: 1, 1: "23", 2: 4}
+
+inventory.clear()
+print(inventory) # []