Adding new algorithms

Author: rlishtaba

.gitignore

@@ -109,4 +109,4 @@ ENV/
 
 /junit-report.xml
 /release.sh
-/debugger.py
+/debugger.*

py_algorithms/array/__init__.py

@@ -0,0 +1,14 @@
+__all__ = [
+    'new_circular_array'
+]
+
+from .circular_array import CircularArray
+
+
+def new_circular_array(size: int = 5) -> CircularArray:
+    """
+    Factory method
+    :param size: initial array size
+    :return: CircularArray
+    """
+    return CircularArray(size)

py_algorithms/array/circular_array.py

@@ -0,0 +1,60 @@
+class CircularArray:
+    __slots__ = '_list', '_front', '_rear', '_n'
+
+    def __init__(self, n):
+        self._list = [None for _ in range(n)]
+        self._n = n
+        self._front = 0
+        self._rear = 0
+
+    def size(self):
+        if self._rear >= self._front:
+            return self._rear - self._front
+        return self._n - (self._front - self._rear)
+
+    def enqueue(self, item):
+        size = self.size()
+        if size == self._n - 1:
+            self._resize(lambda x: x * 2)
+        self._list[self._rear] = item
+        self._rear = (self._rear + 1) % self._n
+
+    def dequeue(self):
+        size = self.size()
+        if size == 0:
+            raise RuntimeError("Empty")
+        data = self._list[self._front]
+        self._list[self._front] = float("inf")
+        self._front = (self._front + 1) % self._n
+        return data
+
+    def _resize(self, strategy_f):
+        new_size = strategy_f(self._n)
+        xs = [None for _ in range(new_size)]
+        i = self._front
+        j = 0
+        while i != self._rear:
+            xs[j] = self._list[i]
+            i = (i + 1) % self._n
+            j += 1
+
+        self._front = 0
+        self._rear = j
+        self._n = new_size
+        self._list = xs
+
+
+if __name__ == '__main__':
+    arr = CircularArray(5)
+    arr.enqueue(1)
+    arr.enqueue(2)
+    arr.enqueue(3)
+    print(arr.dequeue())
+    print(arr.dequeue())
+    arr.enqueue(9)
+    arr.enqueue(4)
+    arr.enqueue(5)
+    arr.enqueue(6)
+    arr.enqueue(7)
+    arr.enqueue(8)
+    arr

py_algorithms/data_structures/__init__.py

@@ -1,3 +1,21 @@
+__all__ = [
+    'new_deque',
+    'Deque',
+    'new_queue',
+    'Queue',
+    'new_stack',
+    'Stack',
+    'new_heap',
+    'Heap',
+    'new_max_heap',
+    'new_min_heap',
+    'new_priority_queue',
+    'PriorityQueue',
+    'new_suffix_array',
+    'new_tree_node',
+    'TreeNode',
+]
+
 from typing import Any
 from typing import Callable
 from typing import List
@@ -12,25 +30,10 @@
 from .queue import Queue
 from .stack import Stack
 from .suffix_array import SuffixArray
+from .tree_node import TreeNode
 
 T = TypeVar('T')
 
-__all__ = [
-    'new_deque',
-    'Deque',
-    'new_queue',
-    'Queue',
-    'new_stack',
-    'Stack',
-    'new_heap',
-    'Heap',
-    'new_max_heap',
-    'new_min_heap',
-    'new_priority_queue',
-    'PriorityQueue',
-    'new_suffix_array',
-]
-
 
 def new_deque(collection: List[Any] = ()) -> Deque:
     """
@@ -134,3 +137,7 @@ def new_suffix_array(string: str) -> SuffixArray:
     :return: SuffixArray interface
     """
     return SuffixArray(string)
+
+
+def new_tree_node(element, left=None, right=None):
+    return TreeNode(element=element, left=left, right=right)

py_algorithms/data_structures/stack.py

@@ -28,3 +28,9 @@ def size(self) -> int:
 
     def is_empty(self) -> bool:
         return self._deque.is_empty()
+
+    def peek(self):
+        if self.size > 0:
+            return self._deque.back
+        raise IndexError('Cannot perform top, stack size: {}'
+                         .format(self.size))

py_algorithms/data_structures/tree_node.py

@@ -0,0 +1,34 @@
+from typing import Any
+
+
+class TreeNode:
+    __slots__ = '_left', '_right', '_element'
+
+    def __init__(self, left, right, element=None):
+        self._right = right
+        self._left = left
+        self._element = element
+
+    @property
+    def left(self) -> 'TreeNode':
+        return self._left
+
+    def set_left(self, node: 'TreeNode') -> 'TreeNode':
+        self._left = node
+        return self
+
+    @property
+    def right(self) -> 'TreeNode':
+        return self._right
+
+    def set_right(self, node: 'TreeNode') -> 'TreeNode':
+        self._right = node
+        return self
+
+    @property
+    def element(self) -> Any:
+        return self._element
+
+    def __repr__(self):
+        return "#<{} e={} left={} right={}>" \
+            .format(self.__class__.__name__, self.element, self.left, self.right)

py_algorithms/lists/__init__.py

@@ -0,0 +1,16 @@
+__all__ = [
+    'Node',
+    'new_singly_linked_node',
+    'merge_linked_lists',
+]
+
+from .node import Node
+from .merge_two_sorted import MergeTwoSorted
+
+
+def new_singly_linked_node(data, successor=None):
+    return Node(data, successor)
+
+
+def merge_linked_lists(a: Node, b: Node) -> Node:
+    return MergeTwoSorted.apply(a, b)

py_algorithms/lists/find_merge_point.py

@@ -0,0 +1,23 @@
+from .node import Node
+
+
+class FindMergePoint:
+    @staticmethod
+    def apply(a: Node, b: Node) -> Node:
+        head_a = a
+        head_b = b
+        i = 0
+        while head_a != head_b:
+            if head_a.next is None:
+                head_a = b
+            else:
+                head_a = head_a.next
+
+            if head_b.next is None:
+                head_b = a
+            else:
+                head_b = head_b.next
+            i += 1
+            print(i)
+
+        return head_b

py_algorithms/lists/merge_two_sorted.py

@@ -0,0 +1,26 @@
+from .node import Node
+
+
+class MergeTwoSorted:
+    @staticmethod
+    def apply(a: Node, b: Node) -> Node:
+        ptr = Node(-1, None)
+        head = ptr
+        while a is not None and b is not None:
+
+            if a.data < b.data:
+                head.next = a
+                a = a.next
+            else:
+                head.next = b
+                b = b.next
+
+            head = head.next
+
+        if a:
+            head.next = a
+
+        if b:
+            head.next = b
+
+        return ptr.next

py_algorithms/lists/node.py

@@ -0,0 +1,28 @@
+class Node:
+    __slots__ = '_data', '_next'
+
+    def __init__(self, data, successor):
+        self._next = successor
+        self._data = data
+
+    @property
+    def data(self):
+        return self._data
+
+    @property
+    def next(self):
+        return self._next
+
+    @next.setter
+    def next(self, other: 'Node'):
+        if other is None:
+            self._next = None
+            return
+
+        if not isinstance(other, self.__class__):
+            raise ValueError("Type invariant violation.")
+        self._next = other
+
+    def __repr__(self):
+        return '#<{} data={} next={}>' \
+            .format(self.__class__.__name__, self.data, self.next)

py_algorithms/stacks/__init__.py

@@ -0,0 +1,32 @@
+from typing import List
+
+from ..data_structures import new_stack
+
+
+class FindingSpans:
+    """
+
+    """
+
+    @staticmethod
+    def apply(xs: List[int]):
+        stack = new_stack()
+        state = [float('inf') for _ in range(len(xs))]
+
+        for i in range(0, len(xs)):
+            while not stack.is_empty() and xs[i] > xs[stack.peek()]:
+                stack.pop()
+
+            if stack.is_empty():
+                p = -1
+            else:
+                p = stack.peek()
+
+            state[i] = i - p
+            stack.push(i)
+        return state
+
+
+if __name__ == '__main__':
+    data = [6, 3, 4, 5, 2]
+    assert FindingSpans.apply(data) == []

py_algorithms/stacks/finding_spans.py

@@ -0,0 +1,33 @@
+from typing import Any
+from typing import List
+
+
+class ReplaceWithNearestGreatest:
+    @staticmethod
+    def apply(xs: List[Any]) -> List[Any]:
+        result = []
+        stack = [xs[0]]
+        for i in range(0, len(xs)):
+            nearest_gt = xs[i]
+            if len(stack) > 0:
+                element = stack.pop()
+                while element < nearest_gt:
+                    result.append(nearest_gt)
+                    if len(stack) == 0:
+                        break
+                    element = stack.pop()
+                if element > nearest_gt:
+                    stack.append(element)
+            stack.append(nearest_gt)
+
+        while len(stack) > 0:
+            stack.pop()
+            result.append(float('inf'))
+
+        return result
+
+
+if __name__ == '__main__':
+    f = ReplaceWithNearestGreatest()
+    _xs = [0, 0, 1, 0, 3, 0, 4]
+    assert f.apply(_xs) == [1, 3, 3, 4, 4, float('inf')]

py_algorithms/stacks/replace_with_nearest_gt.py

@@ -0,0 +1,37 @@
+from typing import List
+
+
+class GenBinStringsWithNBits1:
+    def __call__(self, n: int) -> List[str]:
+        if n == 0:
+            return []
+        if n == 1:
+            return ['0', '1']
+
+        xs = []
+
+        for bitstring in self(n - 1):
+            for digit in self(1):
+                xs.append(digit + bitstring)
+
+        return xs
+
+
+class GenBinStringsWithNBits2:
+    def __call__(self, num: int, f) -> List[str]:
+        if num == 0:
+            return []
+        if num == 1:
+            return ['0', '1']
+        left = f('0', self(num - 1, f))
+        right = f('1', self(num - 1, f))
+        return left + right
+
+
+def _append_at_beginning_front(x, xs):
+    return [x + element for element in xs]
+
+
+if __name__ == '__main__':
+    print(GenBinStringsWithNBits1()(4))
+    print(GenBinStringsWithNBits2()(4, _append_at_beginning_front))