initial commit

rotsix · rotsix · commit 88381fe96ef1 · 2020-06-09T18:38:06.000+02:00
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,143 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# static files generated from Django application using `collectstatic`
+media
+static
diff --git a/binarytree.py b/binarytree.py
@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+
+
+class AlreadyExistsError(Exception):
+    pass
+
+
+class BinaryTree:
+    def __init__(self, value, left=None, right=None):
+        self._value = value
+        self._left = left
+        self._right = right
+
+    def __contains__(self, value):
+        if value < self._value:
+            return self._left and value in self._left
+        if value > self._value:
+            return self._right and value in self._right
+        return True
+
+    def __repr__(self):
+        res = ""
+        if self._left:
+            res += str(self._left) + ", "
+        res += str(self._value)
+        if self._right:
+            res += ", " + str(self._right)
+        return res
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self._left:
+            yield from self._left
+        yield self._value
+        if self._right:
+            yield from self._right
+        raise StopIteration
+
+    def insert(self, value):
+        if self._value == value:
+            raise AlreadyExistsError
+        if value < self._value:
+            if not self._left:
+                self._left = BinaryTree(value)
+            elif self._left._value < value:
+                tmp = self._left
+                self._left = BinaryTree(value, left=tmp)
+            else:
+                self._left.insert(value)
+        if value > self._value:
+            if not self._right:
+                self._right = BinaryTree(value)
+            elif self._right._value > value:
+                tmp = self._right
+                self._right = BinaryTree(value, right=tmp)
+            else:
+                self._right.insert(value)
+
+    def remove(self, value):
+        pass
+
+
+if __name__ == "__main__":
+    bt = BinaryTree(5)
+    # insert
+    bt.insert(9)
+    bt.insert(3)
+    bt.insert(7)
+    bt.insert(2)
+    bt.insert(6)
+    bt.insert(4)
+    bt.insert(8)
+    bt.insert(1)
+    bt.insert(0)
+    witness = list(range(10))
+    assert list(bt) == witness
diff --git a/hashmap.py b/hashmap.py
@@ -0,0 +1,148 @@
+#!/usr/bin/env python
+
+from linkedlist import LinkedList
+
+
+class HashMap:
+    def __init__(self, **kwargs):
+        self._occupied = self._old_occupied = 0
+        self._size = 2
+        self._store = [None] * self._size
+        self._load_factor = 0.75
+        self._resizing = False
+
+        # used to increase capacity
+        self._old_size = None
+        self._old_store = None
+        # how many to transfer at a time
+        self._resize_factor = 5
+
+        for (k, v) in kwargs:
+            self[k] = v
+
+    def __getitem__(self, key):
+        def lookup(store, size):
+            index = hash(key) % size
+            for (k, v) in store[index]:
+                if key == k:
+                    return v
+
+        if value := lookup(self._store, self._size):
+            return value
+        if value := lookup(self._old_store, self._old_size):
+            return value
+        raise KeyError
+
+    def __setitem__(self, key, value, transfer=False):
+        if (
+            self._occupied >= self._load_factor * self._size
+            and not self._resizing  # already resizing
+            and not transfer  # during transfer
+        ):
+            # resizing:
+            self._occupied = 0
+            # - copy the actual store
+            self._old_store = self._store
+            self._old_size = self._size
+            # - allocate a bigger one
+            self._size *= 2
+            self._store = [None] * self._size
+            # - start transfering
+            self._resizing = True
+
+        if not transfer:
+            self._transfer()
+
+        self._occupied += 1
+        index = hash(key) % self._size
+        if self._store[index]:
+            for (k, v) in self._store[index]:
+                if k == key:
+                    self._store[index].remove((k, v))
+            self._store[index].append((key, value))
+        else:
+            self._store[index] = LinkedList((key, value))
+
+    def __delitem__(self, key):
+        def rm(store, size):
+            try:
+                index = hash(key) % size
+                if not store[index]:
+                    return
+                for (k, v) in store[index]:
+                    if k == key:
+                        store[index].remove((k, v))
+            except ValueError:
+                raise IndexError
+
+        if self._resizing:
+            rm(self._old_store, self._old_size)
+        rm(self._store, self._size)
+        self._occupied -= 1
+
+    def __iter__(self):
+        # TODO
+        return self
+
+    def __repr__(self):
+        values = []
+        if self._resizing:
+            for ll in filter(bool, self._old_store):
+                values += [f"{k}: {v}" for (k, v) in ll]
+        for ll in filter(bool, self._store):
+            values += [f"{k}: {v}" for (k, v) in ll]
+        values = map(str, values)
+        return "{" + ", ".join(values) + "}"
+
+    def __contains__(self, key):
+        def search(store):
+            for ll in filter(bool, store):
+                for (k, v) in ll:
+                    if k == key:
+                        return True
+
+        return (self._old_store and search(self._old_store)) or search(self._store)
+
+    def _transfer(self):
+        if not self._resizing:
+            return
+        remaining = self._resize_factor
+        for index, ll in enumerate(filter(bool, self._old_store)):
+            if remaining == 0:
+                return
+            remaining -= 1
+            self._old_store[index] = None
+            for (k, v) in ll:
+                self._occupied += 1
+                index = hash(k)
+                self.__setitem__(k, v, transfer=True)
+        else:
+            # all None, we're done transfering
+            self._resizing = False
+            self._old_store = None
+            self._old_size = 0
+
+
+if __name__ == "__main__":
+    hm = HashMap()
+    # add
+    for i in range(7):
+        hm[i] = i
+    witness = {i: i for i in range(7)}
+    assert dict(hm) == witness
+
+    # update
+    for i in range(5):
+        hm[i] = 2 * i
+    witness = {i: 2 * i for i in range(7)}
+    assert dict(hm) == witness
+
+    # remove
+    for i in range(0, 7, 2):
+        del hm[i]
+    witness = {i: 2 * i for i in range(0, 7, 2)}
+    assert dict(hm) == witness
+
+    # contains
+    assert 1 in hm
+    assert 666 not in hm
diff --git a/linkedlist.py b/linkedlist.py
