Numerous significant improvements Beta

ciphers/atbash.py

@@ -3,52 +3,34 @@
 import string
 
 
-def atbash_slow(sequence: str) -> str:
+def atbash(text: str) -> str:
     """
-    >>> atbash_slow("ABCDEFG")
-    'ZYXWVUT'
+    Encodes or decodes text using the Atbash cipher.
 
-    >>> atbash_slow("aW;;123BX")
-    'zD;;123YC'
-    """
-    output = ""
-    for i in sequence:
-        extract = ord(i)
-        if 65 <= extract <= 90:
-            output += chr(155 - extract)
-        elif 97 <= extract <= 122:
-            output += chr(219 - extract)
-        else:
-            output += i
-    return output
-
-
-def atbash(sequence: str) -> str:
-    """
-    >>> atbash("ABCDEFG")
-    'ZYXWVUT'
-
-    >>> atbash("aW;;123BX")
-    'zD;;123YC'
-    """
-    letters = string.ascii_letters
-    letters_reversed = string.ascii_lowercase[::-1] + string.ascii_uppercase[::-1]
-    return "".join(
-        letters_reversed[letters.index(c)] if c in letters else c for c in sequence
-    )
+    The Atbash cipher substitutes each letter with its mirror in the alphabet:
+    A -> Z, B -> Y, C -> X, ... Z -> A (case is preserved)
+    Non-alphabetic characters are left unchanged.
 
+    Args:
+        text: The input string to encode/decode
 
-def benchmark() -> None:
-    """Let's benchmark our functions side-by-side..."""
-    from timeit import timeit
+    Returns:
+        The transformed string
+    """
+    # Create translation tables for uppercase and lowercase
+    lowercase_map = str.maketrans(string.ascii_lowercase, string.ascii_lowercase[::-1])
+    uppercase_map = str.maketrans(string.ascii_uppercase, string.ascii_uppercase[::-1])
 
-    print("Running performance benchmarks...")
-    setup = "from string import printable ; from __main__ import atbash, atbash_slow"
-    print(f"> atbash_slow(): {timeit('atbash_slow(printable)', setup=setup)} seconds")
-    print(f">      atbash(): {timeit('atbash(printable)', setup=setup)} seconds")
+    # Apply both translation mappings
+    return text.translate(lowercase_map).translate(uppercase_map)
 
 
+# Example usage
 if __name__ == "__main__":
-    for example in ("ABCDEFGH", "123GGjj", "testStringtest", "with space"):
-        print(f"{example} encrypted in atbash: {atbash(example)}")
-    benchmark()
+    test_string = "Hello, World! 123"
+    encoded = atbash(test_string)
+    decoded = atbash(encoded)
+
+    print(f"Original:  {test_string}")
+    print(f"Encoded:   {encoded}")
+    print(f"Decoded:   {decoded}")

data_structures/heap/skew_heap.py

@@ -2,25 +2,23 @@
 
 from __future__ import annotations
 
-from collections.abc import Iterable, Iterator
-from typing import Any, Generic, TypeVar
+from collections.abc import Callable, Iterable, Iterator
+from typing import Any
 
-T = TypeVar("T", bound=bool)
 
-
-class SkewNode(Generic[T]):
+class SkewNode:
     """
     One node of the skew heap. Contains the value and references to
     two children.
     """
 
-    def __init__(self, value: T) -> None:
-        self._value: T = value
-        self.left: SkewNode[T] | None = None
-        self.right: SkewNode[T] | None = None
+    def __init__(self, value: Any) -> None:
+        self._value: Any = value
+        self.left: SkewNode | None = None
+        self.right: SkewNode | None = None
 
     @property
-    def value(self) -> T:
+    def value(self) -> Any:
         """
         Return the value of the node.
 
@@ -30,68 +28,56 @@ def value(self) -> T:
         3.14159
         >>> SkewNode("hello").value
         'hello'
-        >>> SkewNode(None).value
-
         >>> SkewNode(True).value
         True
-        >>> SkewNode([]).value
-        []
-        >>> SkewNode({}).value
-        {}
-        >>> SkewNode(set()).value
-        set()
-        >>> SkewNode(0.0).value
-        0.0
-        >>> SkewNode(-1e-10).value
-        -1e-10
         >>> SkewNode(10).value
         10
-        >>> SkewNode(-10.5).value
-        -10.5
-        >>> SkewNode().value
-        Traceback (most recent call last):
-        ...
-        TypeError: SkewNode.__init__() missing 1 required positional argument: 'value'
         """
         return self._value
 
     @staticmethod
     def merge(
-        root1: SkewNode[T] | None, root2: SkewNode[T] | None
-    ) -> SkewNode[T] | None:
+        root1: SkewNode | None, root2: SkewNode | None, comp: Callable[[Any, Any], bool]
+    ) -> SkewNode | None:
         """
-        Merge 2 nodes together.
-        >>> SkewNode.merge(SkewNode(10),SkewNode(-10.5)).value
+        Merge two nodes together.
+        >>> def comp(a, b): return a < b
+        >>> SkewNode.merge(SkewNode(10), SkewNode(-10.5), comp).value
         -10.5
-        >>> SkewNode.merge(SkewNode(10),SkewNode(10.5)).value
+        >>> SkewNode.merge(SkewNode(10), SkewNode(10.5), comp).value
         10
-        >>> SkewNode.merge(SkewNode(10),SkewNode(10)).value
+        >>> SkewNode.merge(SkewNode(10), SkewNode(10), comp).value
         10
-        >>> SkewNode.merge(SkewNode(-100),SkewNode(-10.5)).value
+        >>> SkewNode.merge(SkewNode(-100), SkewNode(-10.5), comp).value
         -100
         """
+        # Handle empty nodes
         if not root1:
             return root2
-
         if not root2:
             return root1
 
-        if root1.value > root2.value:
-            root1, root2 = root2, root1
-
-        result = root1
-        temp = root1.right
-        result.right = root1.left
-        result.left = SkewNode.merge(temp, root2)
-
-        return result
-
-
-class SkewHeap(Generic[T]):
+        # Compare values using provided comparison function
+        if comp(root1.value, root2.value):
+            # root1 is smaller, make it the new root
+            result = root1
+            temp = root1.right
+            result.right = root1.left
+            result.left = SkewNode.merge(temp, root2, comp)
+            return result
+        else:
+            # root2 is smaller or equal, use it as new root
+            result = root2
+            temp = root2.right
+            result.right = root2.left
+            result.left = SkewNode.merge(root1, temp, comp)
+            return result
+
+
+class SkewHeap:
     """
-    A data structure that allows inserting a new value and to pop the smallest
-    values. Both operations take O(logN) time where N is the size of the
-    structure.
+    A data structure that allows inserting a new value and popping the smallest
+    values. Both operations take O(logN) time where N is the size of the heap.
     Wiki: https://en.wikipedia.org/wiki/Skew_heap
     Visualization: https://www.cs.usfca.edu/~galles/visualization/SkewHeap.html
 
@@ -111,20 +97,32 @@ class SkewHeap(Generic[T]):
     [-1, 0, 1]
     """
 
-    def __init__(self, data: Iterable[T] | None = ()) -> None:
+    def __init__(
+        self,
+        data: Iterable[Any] | None = None,
+        comp: Callable[[Any, Any], bool] = lambda a, b: a < b,
+    ) -> None:
         """
+        Initialize the skew heap with optional data and comparison function
+
         >>> sh = SkewHeap([3, 1, 3, 7])
         >>> list(sh)
         [1, 3, 3, 7]
+
+        # Max-heap example
+        >>> max_heap = SkewHeap([3, 1, 3, 7], comp=lambda a, b: a > b)
+        >>> list(max_heap)
+        [7, 3, 3, 1]
         """
-        self._root: SkewNode[T] | None = None
+        self._root: SkewNode | None = None
+        self._comp = comp
         if data:
             for item in data:
                 self.insert(item)
 
     def __bool__(self) -> bool:
         """
-        Check if the heap is not empty.
+        Check if the heap is not empty
 
         >>> sh = SkewHeap()
         >>> bool(sh)
@@ -138,27 +136,31 @@ def __bool__(self) -> bool:
         """
         return self._root is not None
 
-    def __iter__(self) -> Iterator[T]:
+    def __iter__(self) -> Iterator[Any]:
         """
-        Returns sorted list containing all the values in the heap.
+        Iterate through all values in sorted order
 
         >>> sh = SkewHeap([3, 1, 3, 7])
         >>> list(sh)
         [1, 3, 3, 7]
         """
+        # Create a temporary heap for iteration
+        temp_heap = SkewHeap(comp=self._comp)
         result: list[Any] = []
-        while self:
-            result.append(self.pop())
 
-        # Pushing items back to the heap not to clear it.
-        for item in result:
-            self.insert(item)
+        # Pop all elements from the heap
+        while self:
+            item = self.pop()
+            result.append(item)
+            temp_heap.insert(item)
 
+        # Restore the heap state
+        self._root = temp_heap._root
         return iter(result)
 
-    def insert(self, value: T) -> None:
+    def insert(self, value: Any) -> None:
         """
-        Insert the value into the heap.
+        Insert a new value into the heap
 
         >>> sh = SkewHeap()
         >>> sh.insert(3)
@@ -168,11 +170,11 @@ def insert(self, value: T) -> None:
         >>> list(sh)
         [1, 3, 3, 7]
         """
-        self._root = SkewNode.merge(self._root, SkewNode(value))
+        self._root = SkewNode.merge(self._root, SkewNode(value), self._comp)
 
-    def pop(self) -> T | None:
+    def pop(self) -> Any:
         """
-        Pop the smallest value from the heap and return it.
+        Remove and return the smallest value from the heap
 
         >>> sh = SkewHeap([3, 1, 3, 7])
         >>> sh.pop()
@@ -189,15 +191,13 @@ def pop(self) -> T | None:
         IndexError: Can't get top element for the empty heap.
         """
         result = self.top()
-        self._root = (
-            SkewNode.merge(self._root.left, self._root.right) if self._root else None
-        )
-
+        if self._root:
+            self._root = SkewNode.merge(self._root.left, self._root.right, self._comp)
         return result
 
-    def top(self) -> T:
+    def top(self) -> Any:
         """
-        Return the smallest value from the heap.
+        Return the smallest value without removing it
 
         >>> sh = SkewHeap()
         >>> sh.insert(3)
@@ -219,7 +219,7 @@ def top(self) -> T:
 
     def clear(self) -> None:
         """
-        Clear the heap.
+        Clear all elements from the heap
 
         >>> sh = SkewHeap([3, 1, 3, 7])
         >>> sh.clear()

data_structures/stacks/stack_with_doubly_linked_list.py

@@ -3,19 +3,15 @@
 
 from __future__ import annotations
 
-from typing import Generic, TypeVar
 
-T = TypeVar("T")
-
-
-class Node(Generic[T]):
+class Node[T]:
     def __init__(self, data: T):
         self.data = data  # Assign data
         self.next: Node[T] | None = None  # Initialize next as null
         self.prev: Node[T] | None = None  # Initialize prev as null
 
 
-class Stack(Generic[T]):
+class Stack[T]:
     """
     >>> stack = Stack()
     >>> stack.is_empty()