Merge pull request #15 from rlishtaba/feature/algorithms

Adding new algorithms

Author: rlishtaba

.gitignore

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

README.md

@@ -33,12 +33,12 @@ $ pip install py-algorithms
         - Min PQ
         - Max PQ
       - Suffix Array
-      
+
 ---
 
 ### Search
       - Binary Search
-      
+
 ---
 
 ### Sort
@@ -49,43 +49,51 @@ $ pip install py-algorithms
       - Comb Sort
       - Bubble Sort
       - Selection Sort
-      
+
 ---
 
 ### Graph Algorithms
       - Depth-First-Search (DFS)
-      - Breadth-First-Search (BFS) 
+      - Breadth-First-Search (BFS)
       - Topologial sort
       - Floyd–Warshall algorithm
-      
+
 ---
 
-### String Algorithms 
+### String Algorithms
       - Patttern Matching
-      - Boyer–Moore string search 
-      - Knut-Morris-Prat string search 
-      
----    
+      - Boyer–Moore string search
+      - Knut-Morris-Prat string search
+
+---
 
 ### Primality Tests
       - Miller-Rabin primality test
       - Simple primality test
-      
+
 ---
-    
+
 ### Algorithms
       - Quick Union
       - Union Find
       - Weighted Union Find
       - Weighted Union Find with Path Compression
-      
+
+---
+
+### Dynamic Programing (DP)
+
+      - Longest Increasing Subsequence (LIS)
+      - Levenshtein Distance
+      - 0-1 Knapsack Problem
+
 ---
 
 ### Challenges
       - TopCoder (www.topcoder.com)
       - HackerRank problems & submissions (https://www.hackerrank.com)
       - CoderByte challenges (https://coderbyte.com)
-      
+
 ---
 
 ### Challenges
@@ -492,11 +500,11 @@ ds.is_sub_str('blah') #=> False
 
 #### Topological sort
 
-In the field of computer science, a topological sort or topological ordering of a directed graph is a 
+In the field of computer science, a topological sort or topological ordering of a directed graph is a
 linear ordering of its vertices such that for every directed edge uv from vertex u to vertex v, u comes before v in the ordering.
-For instance, the vertices of the graph may represent tasks to be performed, and the edges may represent 
-constraints that one task must be performed before another; in this application, a topological ordering is just a valid sequence for the tasks. 
-A topological ordering is possible if and only if the graph has no directed cycles, that is, if it is a directed acyclic graph (DAG). 
+For instance, the vertices of the graph may represent tasks to be performed, and the edges may represent
+constraints that one task must be performed before another; in this application, a topological ordering is just a valid sequence for the tasks.
+A topological ordering is possible if and only if the graph has no directed cycles, that is, if it is a directed acyclic graph (DAG).
 Any DAG has at least one topological ordering, and algorithms are known for constructing a topological ordering of any DAG in linear time.
 
 ![topo-sort](http://www.stoimen.com/blog/wp-content/uploads/2012/10/2.-Topological-Sort.png)
@@ -521,7 +529,7 @@ dag.insert_edge(d, e, None)
 topological_sort_f1(dag) #=> [#<Vertex(C)>, #<Vertex(B)>, #<Vertex(D)>, #<Vertex(A)>, #<Vertex(E)>]
 
 ```
-    
+
 ---
 
 ### String Algorithms
@@ -530,11 +538,11 @@ topological_sort_f1(dag) #=> [#<Vertex(C)>, #<Vertex(B)>, #<Vertex(D)>, #<Vertex
 
 #### Boyer–Moore string search algorithm
 
-In computer science, the Boyer–Moore string search algorithm is an efficient string searching algorithm that 
+In computer science, the Boyer–Moore string search algorithm is an efficient string searching algorithm that
 is the standard benchmark for practical string search literature. It was developed by Robert S. Boyer and J Strother Moore in 1977.
-The algorithm preprocesses the string being searched for (the pattern), but not the string being searched in (the text). 
-It is thus well-suited for applications in which the pattern is much shorter than the text or where it persists across multiple searches. 
-The Boyer-Moore algorithm uses information gathered during the preprocess step to skip sections of the text, 
+The algorithm preprocesses the string being searched for (the pattern), but not the string being searched in (the text).
+It is thus well-suited for applications in which the pattern is much shorter than the text or where it persists across multiple searches.
+The Boyer-Moore algorithm uses information gathered during the preprocess step to skip sections of the text,
 resulting in a lower constant factor than many other string search algorithms.
 
 ```python
@@ -555,18 +563,18 @@ algorithm('foo' + substr + 'bar', substr) # => 3
 ![primes](https://upload.wikimedia.org/wikipedia/commons/thumb/9/9e/Gaussian_integer_lattice.svg/389px-Gaussian_integer_lattice.svg.png)
 
 A primality test is an algorithm for determining whether an input number is prime.
-Among other fields of mathematics, it is used for cryptography. 
-Unlike integer factorization, primality tests do not generally give prime factors, only stating whether the input number 
-is prime or not. Factorization is thought to be a computationally difficult problem, whereas primality 
-testing is comparatively easy (its running time is polynomial in the size of the input). 
-Some primality tests prove that a number is prime, while others like Miller–Rabin prove that a number is composite. 
+Among other fields of mathematics, it is used for cryptography.
+Unlike integer factorization, primality tests do not generally give prime factors, only stating whether the input number
+is prime or not. Factorization is thought to be a computationally difficult problem, whereas primality
+testing is comparatively easy (its running time is polynomial in the size of the input).
+Some primality tests prove that a number is prime, while others like Miller–Rabin prove that a number is composite.
 Therefore, the latter might be called compositeness tests instead of primality tests.
 
 
 #### Miller-Rabin Primality Test
- 
-The Miller–Rabin primality test or Rabin–Miller primality test is a primality test: an algorithm which determines whether a given number is prime, 
-similar to the Fermat primality test and the Solovay–Strassen primality test. Its original version, due to Gary L. Miller, is deterministic, 
+
+The Miller–Rabin primality test or Rabin–Miller primality test is a primality test: an algorithm which determines whether a given number is prime,
+similar to the Fermat primality test and the Solovay–Strassen primality test. Its original version, due to Gary L. Miller, is deterministic,
 but the correctness relies on the unproven Extended Riemann hypothesis; Michael O. Rabin modified it to obtain an unconditional probabilistic algorithm.
 
 ```python
@@ -575,7 +583,7 @@ from py_algorithms.primality_tests import new_miller_rabin_primality_test
 algorithm = new_miller_rabin_primality_test()
 
 algorithm(199) #=> True, 199 is a prime number
-algorithm(4) #=> False, 4 % 2 == 0, therefore, 4 is not a prime number. 
+algorithm(4) #=> False, 4 % 2 == 0, therefore, 4 is not a prime number.
 
 ```
 
@@ -590,12 +598,40 @@ from py_algorithms.primality_tests import new_simple_primality_test
 algorithm = new_simple_primality_test()
 
 algorithm(32416190071) #=> True, 32416190071 is a prime number
-algorithm(4) #=> False, 4 % 2 == 0, therefore, 4 is not a prime number. 
+algorithm(4) #=> False, 4 % 2 == 0, therefore, 4 is not a prime number.
 
 ```
 
 ---
 
+### Dynamic Programing (DP)
+In computer science, mathematics, management science, economics and bioinformatics,
+dynamic programming (also known as dynamic optimization) is a method for solving a complex problem
+by breaking it down into a collection of simpler subproblems, solving each of those subproblems
+just once, and storing their solutions. The next time the same subproblem occurs,
+instead of recomputing its solution, one simply looks up the previously computed solution,
+thereby saving computation time at the expense of a (hopefully) modest expenditure in storage space.
+(Each of the subproblem solutions is indexed in some way, typically based on the values of its input parameters,
+so as to facilitate its lookup.) The technique of storing solutions to subproblems instead of recomputing them is called "memoization".
+
+
+###
+In information theory, Linguistics and computer science, the Levenshtein distance is a string metric for measuring the difference between two sequences.
+Informally, the Levenshtein distance between two words is the minimum number of single-character edits (insertions, deletions or substitutions) required to change one word into the other.
+It is named after Vladimir Levenshtein, who considered this distance in 1965.
+Levenshtein distance may also be referred to as edit distance, although that term may also denote a larger family of distance metrics.
+
+It is closely related to pairwise string alignments.
+
+```python
+from py_algorithms.strings import new_levenshtein_distance
+
+distance = new_levenshtein_distance(list('Moon'), list("Moore"))
+assert 2 == distance
+```
+
+---------
+
 
 ## Contributing
 

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)