edit the code

Author: ebrahimbeiati

Sprint-2/implement_linked_list/linked_list_test.py

@@ -2,6 +2,7 @@
 
 from linked_list import LinkedList
 
+
 class LinkedListTest(unittest.TestCase):
     def test_pushes_then_pops(self):
         l = LinkedList()
@@ -31,7 +32,7 @@ def test_remove_tail(self):
         l.remove(a)
         self.assertEqual(l.head, b)
         self.assertEqual(l.tail, b)
-        self.assertIsNone(b.next)
+        self.assertIsNone(b.forward)
         self.assertIsNone(b.previous)
 
 

Sprint-2/implement_skip_list/skip_list.py

@@ -1,134 +1,72 @@
-import math
+import random
 
 
 class Node:
-    def __init__(self, value, next=None):
+    def __init__(self, height, value):
         self.value = value
-        self.next = next
+        self.forward = [None] * height
 
 
 class SkipList:
+    MAX_HEIGHT = 16
+    P = 0.5
+
     def __init__(self):
-        self.head = None
+        self.head = Node(self.MAX_HEIGHT, None)
+        self.level = 1
         self.length = 0
-        self.skips = []  # list of skip pointers, each is a tuple (index, value)
 
-    def _get_node(self, index):
-        """Get the node at the given index."""
+    def __len__(self):
+        return self.length
+
+    def random_height(self):
+        height = 1
+        while random.random() < self.P and height < self.MAX_HEIGHT:
+            height += 1
+        return height
+
+    def _find_updated_path(self, value):
+        update = [None] * self.MAX_HEIGHT
         current = self.head
-        for _ in range(index):
-            if current is None:
-                return None
-            current = current.next
-        return current
-
-    def rebuild_skips(self):
-        """Rebuild the skip pointer so we can jump over sqrt(n) elements."""
-        n = self.length
-        if n == 0:
-            self.skips = []
-            return
+        for i in range(self.level - 1, -1, -1):
+            while current.forward[i] and current.forward[i].value < value:
+                current = current.forward[i]
+            update[i] = current
+        return update
 
-        step = int(math.sqrt(n)) or 1
-        self.skips = list(range(0, n, step))
-
-    def _find_position(self, value):
-        """Find the position to insert value using skip pointers."""
-        if self.length == 0:
-            return 0
-
-        # Use skip pointers to find the range where value should be
-        for i in range(len(self.skips) - 1):
-            a = self.skips[i]
-            b = self.skips[i + 1]
-
-            node_a = self._get_node(a)
-            node_b = node_a
-            for _ in range(b - a):
-                if node_b:
-                    node_b = node_b.next
-
-            if node_a.value <= value < node_b.value:
-                # linear search between a and b
-                idx = a
-                current = node_a
-                while idx < b and current:
-                    if current.value >= value:
-                        return idx
-                    current = current.next
-                    idx += 1
-                return b
-        # Check the last skip pointer
-        start = self.skips[-1]
-        idx = start
-        current = self._get_node(start)
-        while current:
-            if current.value >= value:
-                return idx
-            current = current.next
-            idx += 1
-        return self.length
+    def __contains__(self, value):
+        current = self.head
+
+        for i in range(self.level - 1, -1, -1):
+            while current.forward[i] and current.forward[i].value < value:
+                current = current.forward[i]
+
+        current = current.forward[0]
+        return current is not None and current.value == value
 
     def insert(self, value):
-        """Insert value into the skip list, maintaining sorted order."""
-        pos = self._find_position(value)
-
-        if pos < self.length:
-            node_at_pos = self._get_node(pos)
-            if node_at_pos and node_at_pos.value == value:
-                return  # value already exists, do not insert duplicates
-        # Insert the new node
-        new_node = Node(value)
-        if pos == 0:
-            new_node.next = self.head
-            self.head = new_node
-        else:
-            prev_node = self._get_node(pos - 1)
-            new_node.next = prev_node.next
-            prev_node.next = new_node
-        self.length += 1
-        self.rebuild_skips()
+        update = self._find_updated_path(value)
+        forward_node = update[0].forward[0]
 
-    def __contains__(self, value):
-        if self.length == 0:
-            return False
-
-        for i in range(len(self.skips) - 1):
-            a = self.skips[i]
-            b = self.skips[i + 1]
-
-            node_a = self._get_node(a)
-            node_b = node_a
-            for _ in range(b - a):
-                if node_b:
-                    node_b = node_b.next
-
-            if node_a.value <= value < node_b.value:
-                idx = a
-                current = node_a
-                while idx < b and current:
-                    if current.value == value:
-                        return True
-                    current = current.next
-                    idx += 1
-                return False
-        start = self.skips[-1]
-        idx = start
-        current = self._get_node(start)
+        if forward_node and forward_node.value == value:
+            return
+        node_height = self.random_height()
+        if node_height > self.level:
+            for i in range(self.level, node_height):
+                update[i] = self.head
+            self.level = node_height
 
-        while current:
-            if current.value == value:
-                return True
-            current = current.next
-            idx += 1
+        new_node = Node(node_height, value)
 
-        return False
+        for i in range(node_height):
+            new_node.forward[i] = update[i].forward[i]
+            update[i].forward[i] = new_node
+        self.length += 1
 
     def to_list(self):
-        """Return the skip list as a regular sorted list."""
         result = []
-        current = self.head
+        current = self.head.forward[0]
         while current:
             result.append(current.value)
-            current = current.next
+            current = current.forward[0]
         return result

Sprint-2/improve_with_precomputing/count_letters/count_letters_test.py

@@ -4,6 +4,7 @@
 
 from count_letters import count_letters
 
+
 class CommonPrefixTest(unittest.TestCase):
     def test_only_upper(self):
         self.assertEqual(count_letters("ABC"), 3)
@@ -25,10 +26,10 @@ def test_long_string(self):
         still_to_include = set(letter for letter in alphabet)
 
         while len(s) < 10000000 or len(still_to_include) > 0:
-            next = random.choice(alphabet)
-            s += next
-            if next in still_to_include:
-                still_to_include.remove(next)
+            forward = random.choice(alphabet)
+            s += forward
+            if forward in still_to_include:
+                still_to_include.remove(forward)
 
         self.assertEqual(count_letters(s), 5)