Implement ruling hash to appropriate complexity of Rabin Karp (#1066)

* Added matrix exponentiation approach for finding fibonacci number.

* Implemented the way of finding nth fibonacci.
* Complexity is about O(log(n)*8)

* Updated the matrix exponentiation approach of finding nth fibonacci.

- Removed some extra spaces    
- Added the complexity of bruteforce algorithm  
- Removed unused function called zerro()  
- Added some docktest based on request

* Updated the matrix exponentiation approach of finding nth fibonacci.

- Removed some extra spaces
- Added the complexity of bruteforce algorithm
- Removed unused function called zerro()
- Added some docktest based on request

* Updated Rabin Karp algorithm.

- Previous solution is based on the hash function of python.
- Implemented ruling hash to get the appropriate complexity of rabin karp.

* Updated Rabin Karp algorithm.

- Previous solution is based on the hash function of python.
- Implemented ruling hash to get the appropriate complexity of rabin karp.

*  Implemented ruling hash to appropriate complexity of Rabin Karp

Added unit pattern testing

strings/rabin_karp.py

@@ -1,6 +1,11 @@
+# Numbers of alphabet which we call base
+alphabet_size = 256
+# Modulus to hash a string
+modulus = 1000003
+
+
 def rabin_karp(pattern, text):
     """
-
     The Rabin-Karp Algorithm for finding a pattern within a piece of text
     with complexity O(nm), most efficient when it is used with multiple patterns
     as it is able to check if any of a set of patterns match a section of text in o(1) given the precomputed hashes.
@@ -12,22 +17,42 @@ def rabin_karp(pattern, text):
     2) Step through the text one character at a time passing a window with the same length as the pattern
         calculating the hash of the text within the window compare it with the hash of the pattern. Only testing
         equality if the hashes match
-
     """
     p_len = len(pattern)
-    p_hash = hash(pattern)
+    t_len = len(text)
+    if p_len > t_len:
+        return False
 
-    for i in range(0, len(text) - (p_len - 1)):
+    p_hash = 0
+    text_hash = 0
+    modulus_power = 1
 
-        # written like this t
-        text_hash = hash(text[i:i + p_len])
-        if text_hash == p_hash and \
-                text[i:i + p_len] == pattern:
+    # Calculating the hash of pattern and substring of text
+    for i in range(p_len):
+        p_hash = (ord(pattern[i]) + p_hash * alphabet_size) % modulus
+        text_hash = (ord(text[i]) + text_hash * alphabet_size) % modulus
+        if i == p_len - 1:
+            continue
+        modulus_power = (modulus_power * alphabet_size) % modulus
+
+    for i in range(0, t_len - p_len + 1):
+        if text_hash == p_hash and text[i : i + p_len] == pattern:
             return True
+        if i == t_len - p_len:
+            continue
+        # Calculating the ruling hash
+        text_hash = (
+            (text_hash - ord(text[i]) * modulus_power) * alphabet_size
+            + ord(text[i + p_len])
+        ) % modulus
     return False
 
 
-if __name__ == '__main__':
+def test_rabin_karp():
+    """
+    >>> test_rabin_karp()
+    Success.
+    """
     # Test 1)
     pattern = "abc1abc12"
     text1 = "alskfjaldsabc1abc1abc12k23adsfabcabc"
@@ -48,3 +73,8 @@ if __name__ == '__main__':
     pattern = "abcdabcy"
     text = "abcxabcdabxabcdabcdabcy"
     assert rabin_karp(pattern, text)
+    print("Success.")
+
+
+if __name__ == "__main__":
+    test_rabin_karp()