solves design hash map

Author: anishLearnsToCode

Diff for: README.md

@@ -1,8 +1,8 @@
 # LeetCode Algorithms
 
-![problems-solved](https://img.shields.io/badge/Problems%20Solved-173/2081-1f425f.svg)
-![problems-solved-java](https://img.shields.io/badge/Java-173/2081-1abc9c.svg)
-![problems-solved-python](https://img.shields.io/badge/Python-173/2081-1abc9c.svg)
+![problems-solved](https://img.shields.io/badge/Problems%20Solved-174/2081-1f425f.svg)
+![problems-solved-java](https://img.shields.io/badge/Java-174/2081-1abc9c.svg)
+![problems-solved-python](https://img.shields.io/badge/Python-174/2081-1abc9c.svg)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](CONTRIBUTING.md)
 [![cp](https://img.shields.io/badge/also%20see-Competitve%20Programming-1f72ff.svg)](https://github.com/anishLearnsToCode/competitive-programming)
 
@@ -194,7 +194,7 @@
 | 703 | [Kth Largest Element in a Stream](https://leetcode.com/problems/kth-largest-element-in-a-stream) | [![Java](assets/java.png)](src/KthLargestElementInAStream.java) [![Python](assets/python.png)](python/k_th_largest_element_in_a_stream.py) |
 | 704 | [Binary Search](https://leetcode.com/problems/binary-search) | [![Java](assets/java.png)](src/BinarySearch.java) [![Python](assets/python.png)](python/binary_search.py) |
 | 705 | [Design HashSet](https://leetcode.com/problems/design-hashset) | [![Java](assets/java.png)](src/DesignHashSet.java) [![Python](assets/python.png)](python/design_hash_set.py) |
-| 706 | [Design HashMap](https://leetcode.com/problems/design-hashmap) | |
+| 706 | [Design HashMap](https://leetcode.com/problems/design-hashmap) | [![Java](assets/java.png)](src/DesignHashMap.java) [![Python](assets/python.png)](python/design_hash_map.py) |
 | 709 | [To Lower Case](https://leetcode.com/problems/to-lower-case) | |
 | 716 | [Max Stack](https://leetcode.com/problems/max-stack) | |
 | 717 | [1-bit and 2-bit Characters](https://leetcode.com/problems/1-bit-and-2-bit-characters) | |

Diff for: python/design_hash_map.py

@@ -0,0 +1,52 @@
+class Bucket:
+    def __init__(self):
+        self.list = []
+
+    def __str__(self):
+        return self.list.__str__()
+
+    def contains(self, key: int) -> bool:
+        for listKey, value in self.list:
+            if key == listKey:
+                return True
+        return False
+
+    def put(self, key: int, value: int) -> None:
+        changed = False
+        for index, (listKey, _) in enumerate(self.list):
+            if listKey == key:
+                self.list[index] = (key, value)
+                changed = True
+                break
+        if not changed:
+            self.list.append((key, value))
+
+    def remove(self, key: int) -> None:
+        if self.contains(key):
+            self.list.remove((key, self.get(key)))
+
+    def get(self, key: int) -> int:
+        if self.contains(key):
+            for listKey, value in self.list:
+                if listKey == key:
+                    return value
+        return -1
+
+
+class MyHashMap:
+
+    def __init__(self):
+        self.initial_size = 100
+        self.buckets = [Bucket() for _ in range(self.initial_size)]
+
+    def _hashCode(self, number: int) -> int:
+        return number % len(self.buckets)
+
+    def put(self, key: int, value: int) -> None:
+        self.buckets[self._hashCode(key)].put(key, value)
+
+    def get(self, key: int) -> int:
+        return self.buckets[self._hashCode(key)].get(key)
+
+    def remove(self, key: int) -> None:
+        self.buckets[self._hashCode(key)].remove(key)

Diff for: src/DesignHashMap.java

@@ -0,0 +1,81 @@
+import java.util.LinkedList;
+import java.util.Objects;
+import java.util.Queue;
+
+public class DesignHashMap {
+    class MyHashMap {
+
+        private final int initialSize = 100;
+        private final Bucket[] buckets = new Bucket[initialSize];
+
+        public MyHashMap() {
+            for (int index = 0 ; index < buckets.length ; index++) {
+                buckets[index] = new Bucket();
+            }
+        }
+
+        public void put(int key, int value) {
+            int hashCode = key % buckets.length;
+            buckets[hashCode].put(key, value);
+        }
+
+        public int get(int key) {
+            return buckets[key % buckets.length].get(key);
+        }
+
+        public void remove(int key) {
+            buckets[key % buckets.length].remove(key);
+        }
+
+        private class Bucket {
+            Queue<Pair> list = new LinkedList<>();
+
+
+            public boolean contains(int element) {
+                return list.stream().anyMatch(pair -> pair.key == element);
+            }
+
+            public void put(int key, int value) {
+                if (contains(key)) {
+                    Pair match = list.stream().filter(pair -> pair.key == key).findFirst().get();
+                    match.value = value;
+                } else {
+                    list.add(new Pair(key, value));
+                }
+            }
+
+            public int get(int key) {
+                return contains(key) ? list.stream().filter(pair -> pair.key == key).findFirst().get().value : -1;
+            }
+
+            public void remove(int key) {
+                if (contains(key)) {
+                    list.remove(new Pair(key, get(key)));
+                }
+            }
+        }
+
+        private class Pair {
+            private final int key;
+            private int value;
+
+            Pair(int key, int value) {
+                this.key = key;
+                this.value = value;
+            }
+
+            @Override
+            public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                Pair pair = (Pair) o;
+                return key == pair.key && value == pair.value;
+            }
+
+            @Override
+            public int hashCode() {
+                return Objects.hash(key, value);
+            }
+        }
+    }
+}