Merge pull request #12 from rlishtaba/feature/new_algorithms

Adding primality tests & string search algorithms

Author: rlishtaba

README.md

@@ -49,6 +49,17 @@ $ pip install py-algorithms
       - Selection Sort
 ---
 
+    ^ String algorithms 
+      - Patttern Matching
+      - Boye-Moor Find 
+      - Knut-Morris-Prat Find
+---
+
+    ^ Primality Tests
+      - Miller-Rabin primality test
+      - Simple primality test
+---
+
     ^ Algorithms
       - Quick Union
       - Union Find
@@ -370,19 +381,15 @@ Make a new heap with `Max` property by supplying functor `(a: any, b: any) => c:
 from py_algorithms.data_structures import new_heap, Heap
 
 heap = new_heap(lambda x, y: (x > y) - (x < y) == 1) # type: Heap
-```
 
-Push distinct key value pairs to the heap
+# Push distinct key value pairs to the heap
 
-```python
 heap.push('Kelly', 1)
 heap.push('Susan', 8)
 heap.push('Ryan', 7)
-```
 
-Heap should manage to keep highest key & value on the top
+# Heap should manage to keep highest key & value on the top
 
-```python
 heap.next_key #=> 'Susan'
 heap.pop()    #=> 8
 ```
@@ -397,11 +404,9 @@ heap = new_max_heap() # type: Heap
 heap.push('Kelly', 1)
 heap.push('Susan', 8)
 heap.push('Ryan', 7)
-```
 
-Heap should manage to keep highest key & value on the top
+# Heap should manage to keep highest key & value on the top
 
-```python
 heap.next_key #=> 'Susan'
 heap.max      #=> 8
 heap.pop()    #=> 8
@@ -417,11 +422,9 @@ heap = new_min_heap() # type: Heap
 heap.push('One', 1)
 heap.push('Eight', -8)
 heap.push('Seven', 7)
-```
 
-Heap should manage to keep lowest key & value on the top
+# Heap should manage to keep lowest key & value on the top
 
-```python
 heap.next_key #=> 'Eight'
 heap.min      #=> -8
 heap.pop()    #=> -8
@@ -469,6 +472,83 @@ ds.is_sub_str('blah') #=> False
 
 ---
 
+---
+
+### String Algorithms
+
+
+
+![boyer-moore-media](https://www.researchgate.net/profile/Monther_Aldwairi/publication/237067573/figure/fig1/AS:299315785420823@1448373852591/Figure-1-The-Boyer-Moore-algorithm-illustrated-while-checking-a-signature-in-Snort.png)
+
+#### Boyer–Moore string search algorithm
+
+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, 
+resulting in a lower constant factor than many other string search algorithms.
+
+```python
+
+from py_algorithms.strings import new_boyer_moore_find
+
+algorithm = new_boyer_moore_find()
+
+substr = 'abcd'
+algorithm('foo' + substr + 'bar', substr) # => 3
+
+```
+
+---
+
+### Primality Test Algorithms
+
+[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. 
+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, 
+but the correctness relies on the unproven Extended Riemann hypothesis; Michael O. Rabin modified it to obtain an unconditional probabilistic algorithm.
+
+```python
+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. 
+
+```
+
+#### Simple Primality Test
+
+The test itself is simple and straightforward, but would work very slow on quite big primes.
+
+
+```python
+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. 
+
+```
+
+---
+
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/rlishtaba/py-algorithms. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

py_algorithms/challenges/various/__init__.py

@@ -0,0 +1,16 @@
+__all__ = [
+    'new_miller_rabin_primality_test',
+    'new_simple_primality_test'
+]
+
+from typing import Callable
+from .miller_rabin_primality_test import MillerRabinPrimalityTest
+from .simple_primality_test import SimplePrimalityTest
+
+
+def new_miller_rabin_primality_test() -> Callable[[int, int], bool]:
+    return MillerRabinPrimalityTest()
+
+
+def new_simple_primality_test() -> Callable[[int], bool]:
+    return SimplePrimalityTest()

py_algorithms/graph/__init__.py

@@ -0,0 +1,32 @@
+from random import randrange
+
+
+class MillerRabinPrimalityTest:
+    def __call__(self, n: int, k: int = 10) -> bool:
+        if n == 2:
+            return True
+        if not n & 1:
+            return False
+
+        def check(a, s, d, n):
+            x = pow(a, d, n)
+            if x == 1:
+                return True
+            for i in range(0, s - 1):
+                if x == n - 1:
+                    return True
+                x = pow(x, 2, n)
+            return x == n - 1
+
+        s = 0
+        d = n - 1
+
+        while d % 2 == 0:
+            d >>= 1
+            s += 1
+
+        for _ in range(0, k):
+            a = randrange(2, n)
+            if not check(a, s, d, n):
+                return False
+        return True

py_algorithms/primality_tests/__init__.py

@@ -0,0 +1,17 @@
+class SimplePrimalityTest:
+    def __call__(self, num: int) -> bool:
+        if num <= 1:
+            return False
+        if num <= 3:
+            return True
+
+        if num % 2 == 0 or num % 3 == 0:
+            return False
+
+        i = 5
+        while i * i < num:
+            if num % i == 0 or num % (i + 2) == 0:
+                return True
+            i += 6
+
+        return True

py_algorithms/primality_tests/miller_rabin_primality_test.py

@@ -0,0 +1,10 @@
+__all__ = [
+    'new_boyer_moore_find'
+]
+
+from typing import Callable
+from .boyer_moore_find import BoyerMooreFind
+
+
+def new_boyer_moore_find() -> Callable[[str, str], int]:
+    return BoyerMooreFind()

py_algorithms/primality_tests/simple_primality_test.py

@@ -0,0 +1,35 @@
+class BoyerMooreFind:
+    def __call__(self, string, substring) -> int:
+        """
+
+        :param string: a string to perform search in.
+        :param substring: a string to find in a target.
+        :return: index of start position if match found, otherwise -1.
+        """
+
+        n = len(string)
+        m = len(substring)
+
+        if m == 0:
+            return 0
+
+        last = {}
+        for k in range(0, m):
+            last[substring[k]] = k
+
+        i = m - 1
+        k = m - 1
+
+        while i < n:
+            if string[i] == substring[k]:
+                if k == 0:
+                    return i
+                else:
+                    i -= 1
+                    k -= 1
+            else:
+                j = last.get(string[i], -1)
+                i += m - min(k, j + 1)
+                k = m - 1
+
+        return -1

py_algorithms/strings/__init__.py

@@ -18,15 +18,25 @@
     keywords=['algorithm', 'algorithms', 'data structure', 'data structures',
               'data structures python', 'containers', 'heaps', 'heap sort',
               'sorting algorithms', 'graphs', 'graph algorithms', 'hashing',
-              'python', 'selection sort', 'selectionsort', 'merge sort', 'mergesort',
-              'bubble sort', 'bubblesort', 'quick sort', 'quick-sort', 'quicksort', 'qsort',
-              'binary search', 'heap', 'fibonacci heap', 'max heap', 'min heap', 'priority queue',
-              'fibonacci priority queue', 'max priority queue', 'min priority queue',
-              'dynamic connectivity', 'union find', 'quick union', 'weighted quick union',
-              'weighted quick union with path compression', 'fibonacci heap sort', 'heapsort',
-              'heap sort', 'shell-sort', 'shell sort', 'shellsort', 'comb sort', 'comb-sort',
+              'python', 'selection sort', 'selectionsort', 'merge sort',
+              'mergesort',
+              'bubble sort', 'bubblesort', 'quick sort', 'quick-sort',
+              'quicksort', 'qsort',
+              'binary search', 'heap', 'fibonacci heap', 'max heap', 'min heap',
+              'priority queue',
+              'fibonacci priority queue', 'max priority queue',
+              'min priority queue',
+              'dynamic connectivity', 'union find', 'quick union',
+              'weighted quick union',
+              'weighted quick union with path compression',
+              'fibonacci heap sort', 'heapsort',
+              'heap sort', 'shell-sort', 'shell sort', 'shellsort', 'comb sort',
+              'comb-sort',
               'combsort', 'coderbyte', 'hackerrank', 'coderbyte challenges',
-              'hackerrank challenges'],
+              'hackerrank challenges', 'boyer-moore',
+              'boyer-moore-string-search', 'primality-tes',
+              'miller-rabin', 'miller-rabin-primality-test',
+              'simple-primality-test'],
     description="Library of Algorithms, Data Structures, variety of solutions to common "
                 "CS problems.",
     long_description="Library of Algorithms, Data Structures, variety of solutions to common "

py_algorithms/strings/boyer_moore_find.py

@@ -1,14 +1,71 @@
 import random
-from typing import List
+from typing import List, Tuple
 
 import pytest
 
+BIG_PRIMES = (
+    32416188037, 32416188691, 32416189321, 32416189919,
+    32416188113, 32416188697, 32416189349, 32416189987,
+    32416188127, 32416188767, 32416189361, 32416190039,
+    32416188191, 32416188793, 32416189381, 32416190071)
+
+PRIMES_0_3000 = (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53,
+                 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113,
+                 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181,
+                 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251,
+                 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317,
+                 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397,
+                 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
+                 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557,
+                 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619,
+                 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701,
+                 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787,
+                 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863,
+                 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953,
+                 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031,
+                 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093,
+                 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171,
+                 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237,
+                 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303,
+                 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409,
+                 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471,
+                 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543,
+                 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607,
+                 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669,
+                 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753,
+                 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847,
+                 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913,
+                 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999,
+                 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081,
+                 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141,
+                 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239,
+                 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309,
+                 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381,
+                 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447,
+                 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549,
+                 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647,
+                 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699,
+                 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767,
+                 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843,
+                 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927,
+                 2939, 2953, 2957, 2963, 2969, 2971, 2999)
+
 
 @pytest.fixture
 def xs() -> List[int]:
     return [0, 6, 7, 8, 9, 4, 5, 12, -1]
 
 
+@pytest.fixture
+def primes_0_3000() -> Tuple[int, ...]:
+    return PRIMES_0_3000
+
+
+@pytest.fixture
+def big_primes() -> Tuple[int, ...]:
+    return BIG_PRIMES
+
+
 @pytest.fixture
 def large_xs() -> List[int]:
     raw = [0, 6, 7, 8, 9, 4, 5, 12, -112] * 500