Merge branch 'master' into add-pigeonhole-sort

Author: goswami-rahul

README.md

@@ -72,7 +72,7 @@ If you want to uninstall algorithms, it is as simple as:
     - [move_zeros](algorithms/arrays/move_zeros.py)
     - [n_sum](algorithms/arrays/n_sum.py)
 - [automata](algorithms/automata)
-    - [DFA](algorithms/automata/DFA.py)
+    - [DFA](algorithms/automata/dfa.py)
 - [backtrack](algorithms/backtrack)
     - [general_solution.md](algorithms/backtrack/)
     - [add_operators](algorithms/backtrack/add_operators.py)
@@ -196,15 +196,16 @@ If you want to uninstall algorithms, it is as simple as:
     - [valid_sudoku](algorithms/map/valid_sudoku.py)
     - [word_pattern](algorithms/map/word_pattern.py)
     - [is_isomorphic](algorithms/map/is_isomorphic.py)
-    - [is_anagram](algorithms/map/is_anagram.py)    
+    - [is_anagram](algorithms/map/is_anagram.py)
 - [maths](algorithms/maths)
+    - [power](algorithms/maths/power.py)
     - [base_conversion](algorithms/maths/base_conversion.py)
     - [combination](algorithms/maths/combination.py)
     - [cosine_similarity](algorithms/maths/cosine_similarity.py)
     - [decimal_to_binary_ip](algorithms/maths/decimal_to_binary_ip.py)
     - [euler_totient](algorithms/maths/euler_totient.py)
     - [extended_gcd](algorithms/maths/extended_gcd.py)
-    - [factorial](algorithms/maths/factorial.py)    
+    - [factorial](algorithms/maths/factorial.py)
     - [gcd/lcm](algorithms/maths/gcd.py)
     - [generate_strobogrammtic](algorithms/maths/generate_strobogrammtic.py)
     - [is_strobogrammatic](algorithms/maths/is_strobogrammatic.py)
@@ -258,6 +259,7 @@ If you want to uninstall algorithms, it is as simple as:
     - [search_rotate](algorithms/search/search_rotate.py)
     - [jump_search](algorithms/search/jump_search.py)
     - [next_greatest_letter](algorithms/search/next_greatest_letter.py)
+    - [interpolation_search](algorithms/search/interpolation_search.py)
 - [set](algorithms/set)
     - [randomized_set](algorithms/set/randomized_set.py)
     - [set_covering](algorithms/set/set_covering.py)
@@ -283,6 +285,7 @@ If you want to uninstall algorithms, it is as simple as:
     - [selection_sort](algorithms/sort/selection_sort.py)
     - [shell_sort](algorithms/sort/shell_sort.py)
     - [sort_colors](algorithms/sort/sort_colors.py)
+    - [stooge_sort](algorithms/sort/stooge_sort.py)
     - [top_sort](algorithms/sort/top_sort.py)
     - [wiggle_sort](algorithms/sort/wiggle_sort.py)
 - [stack](algorithms/stack)
@@ -323,6 +326,7 @@ If you want to uninstall algorithms, it is as simple as:
     - [judge_circle](algorithms/strings/judge_circle.py)
     - [strong_password](algorithms/strings/strong_password.py)
     - [caesar_cipher](algorithms/strings/caesar_cipher.py)
+    - [check_pangram](algorithms/strings/check_pangram.py
     - [contain_string](algorithms/strings/contain_string.py)
     - [count_binary_substring](algorithms/strings/count_binary_substring.py)
     - [repeat_string](algorithms/strings/repeat_string.py)

algorithms/maths/__init__.py

@@ -18,3 +18,4 @@
 from .find_order_simple import *
 from .find_primitive_root_simple import *
 from .diffie_hellman_key_exchange import *
+from .power import *

algorithms/maths/power.py

@@ -0,0 +1,45 @@
+def power(a: int, n: int, r: int = None):
+    """
+    Iterative version of binary exponentiation
+    
+    Calculate a ^ n
+    if r is specified, return the result modulo r
+    
+    Time Complexity :  O(log(n))
+    Space Complexity : O(1)
+    """
+    ans = 1
+    while n:
+        if n & 1:
+            ans = ans * a
+        a = a * a
+        if r:
+            ans %= r
+            a %= r
+        n >>= 1
+    return ans
+
+
+def power_recur(a: int, n: int, r: int = None):
+    """
+    Recursive version of binary exponentiation
+    
+    Calculate a ^ n
+    if r is specified, return the result modulo r
+    
+    Time Complexity :  O(log(n))
+    Space Complexity : O(log(n))
+    """
+    if n == 0:
+        ans = 1
+    elif n == 1:
+        ans = a
+    else:
+        ans = power_recur(a, n // 2, r)
+        ans = ans * ans
+        if n % 2:
+            ans = ans * a
+    if r:
+        ans %= r
+    return ans
+

algorithms/search/__init__.py

@@ -9,3 +9,4 @@
 from .search_rotate import *
 from .jump_search import *
 from .next_greatest_letter import *
+from .interpolation_search import *

algorithms/search/interpolation_search.py

@@ -0,0 +1,53 @@
+""" 
+Python implementation of the Interpolation Search algorithm.
+Given a sorted array in increasing order, interpolation search calculates
+the starting point of its search according to the search key.
+
+FORMULA: start_pos = low + [ (x - arr[low])*(high - low) / (arr[high] - arr[low]) ]
+
+Doc: https://en.wikipedia.org/wiki/Interpolation_search
+
+Time Complexity: O(log2(log2 n)) for average cases, O(n) for the worst case.
+The algorithm performs best with uniformly distributed arrays.
+"""
+
+from typing import List
+
+
+def interpolation_search(array: List[int], search_key: int) -> int:
+    """
+    :param array: The array to be searched.
+    :param search_key: The key to be searched in the array.
+
+    :returns: Index of search_key in array if found, else -1.
+
+    Example
+
+    >>> interpolation_search([1, 10, 12, 15, 20, 41, 55], 20)
+    4
+    >>> interpolation_search([5, 10, 12, 14, 17, 20, 21], 55)
+    -1
+
+    """
+
+    # highest and lowest index in array
+    high = len(array) - 1
+    low = 0
+
+    while low <= high and search_key in range(low, array[high] + 1):
+        # calculate the search position
+        pos = low + int(((search_key - array[low]) *
+                         (high - low) / (array[high] - array[low])))
+
+        # if array[pos] equals the search_key then return pos as the index
+        if search_key == array[pos]:
+            return pos
+        # if the search_key is greater than array[pos] restart the search with the
+        # subarray greater than array[pos]
+        elif search_key > array[pos]:
+            low = pos + 1
+        # in this case start the search with the subarray smaller than current array[pos]
+        elif search_key < array[pos]:
+            high = pos - 1
+
+    return -1

algorithms/sort/__init__.py

@@ -14,6 +14,7 @@
 from .top_sort import *
 from .bucket_sort import *
 from .shell_sort import *
+from .stooge_sort import *
 from .radix_sort import *
 from .gnome_sort import *
 from .cocktail_shaker_sort import *

algorithms/sort/stooge_sort.py

@@ -0,0 +1,43 @@
+'''
+
+Stooge Sort
+Time Complexity : O(n2.709)
+Reference: https://www.geeksforgeeks.org/stooge-sort/
+
+'''
+
+
+
+def stoogesort(arr, l, h): 
+    if l >= h: 
+        return
+   
+    # If first element is smaller 
+    # than last, swap them 
+    if arr[l]>arr[h]: 
+        t = arr[l] 
+        arr[l] = arr[h] 
+        arr[h] = t 
+   
+    # If there are more than 2 elements in 
+    # the array 
+    if h-l + 1 > 2: 
+        t = (int)((h-l + 1)/3) 
+   
+        # Recursively sort first 2 / 3 elements 
+        stoogesort(arr, l, (h-t)) 
+   
+        # Recursively sort last 2 / 3 elements 
+        stoogesort(arr, l + t, (h)) 
+   
+        # Recursively sort first 2 / 3 elements 
+        # again to confirm 
+        stoogesort(arr, l, (h-t)) 
+        
+
+if __name__ == "__main__":
+    array = [1,3,64,5,7,8]
+    n = len(array) 
+    stoogesort(array, 0, n-1) 
+    for i in range(0, n): 
+        print(array[i], end = ' ') 

algorithms/strings/__init__.py

@@ -25,6 +25,7 @@
 from .judge_circle import *
 from .strong_password import *
 from .caesar_cipher import *
+from .check_pangram import *
 from .contain_string import *
 from .count_binary_substring import *
 from .repeat_string import *

algorithms/strings/check_pangram.py

@@ -0,0 +1,10 @@
+"""
+Algorithm that checks if a given string is a pangram or not
+"""
+
+def check_pangram(input_string):
+    alphabet = "abcdefghijklmnopqrstuvwxyz"
+    for ch in alphabet:
+        if ch not in input_string.lower():
+            return False
+    return True 

algorithms/strings/is_palindrome.py

@@ -21,9 +21,9 @@ def is_palindrome(s):
     i = 0
     j = len(s)-1
     while i < j:
-        while i < j and not s[i].isalnum():
+        while not s[i].isalnum():
             i += 1
-        while i < j and not s[j].isalnum():
+        while not s[j].isalnum():
             j -= 1
         if s[i].lower() != s[j].lower():
             return False

tests/test_maths.py

@@ -1,4 +1,5 @@
 from algorithms.maths import (
+    power,power_recur,
     int_to_base, base_to_int,
     decimal_to_binary_ip,
     euler_totient,
@@ -25,6 +26,27 @@
 import unittest
 
 
+class TestPower(unittest.TestCase):
+    """
+    Test for the file power.py
+
+    Arguments:
+        unittest {[type]} -- [description]
+    """
+
+    def test_power(self):
+        self.assertEqual(8, power(2, 3))
+        self.assertEqual(1, power(5, 0))
+        self.assertEqual(0, power(10, 3, 5))
+        self.assertEqual(280380, power(2265, 1664,465465))
+
+    def test_power_recur(self):
+        self.assertEqual(8, power_recur(2, 3))
+        self.assertEqual(1, power_recur(5, 0))
+        self.assertEqual(0, power_recur(10, 3, 5))
+        self.assertEqual(280380, power_recur(2265, 1664,465465))
+
+
 class TestBaseConversion(unittest.TestCase):
     """
     Test for the file base_conversion.py

tests/test_search.py

@@ -9,11 +9,13 @@
     find_min_rotate, find_min_rotate_recur,
     search_rotate, search_rotate_recur,
     jump_search,
-    next_greatest_letter, next_greatest_letter_v1, next_greatest_letter_v2
+    next_greatest_letter, next_greatest_letter_v1, next_greatest_letter_v2,
+    interpolation_search
 )
 
 import unittest
 
+
 class TestSuite(unittest.TestCase):
 
     def test_first_occurrence(self):
@@ -56,7 +58,7 @@ def test_linear_search(self):
         self.assertEqual(-1, linear_search(array, -1))
 
     def test_search_insert(self):
-        array = [1,3,5,6]
+        array = [1, 3, 5, 6]
         self.assertEqual(2, search_insert(array, 5))
         self.assertEqual(1, search_insert(array, 2))
         self.assertEqual(4, search_insert(array, 7))
@@ -122,6 +124,16 @@ def test_next_greatest_letter(self):
         self.assertEqual("c", next_greatest_letter_v1(letters, target))
         self.assertEqual("c", next_greatest_letter_v2(letters, target))
 
+    def test_interpolation_search(self):
+        array = [0, 3, 5, 5, 9, 12, 12, 15, 16, 19, 20]
+        self.assertEqual(1, interpolation_search(array, 3))
+        self.assertEqual(2, interpolation_search(array, 5))
+        self.assertEqual(6, interpolation_search(array, 12))
+        self.assertEqual(-1, interpolation_search(array, 22))
+        self.assertEqual(-1, interpolation_search(array, -10))
+        self.assertEqual(10, interpolation_search(array, 20))
+
+
 if __name__ == '__main__':
 
     unittest.main()