first_unique_function

Author: bodda93

algorithms/maths/find_order_simple.py

@@ -11,17 +11,42 @@
 
 import math
 
+branch_coverage = {
+    "branch_6": False,
+    "branch_7": False,
+    "branch_8": False,
+    "branch_9": False,
+    "branch_10": False   
+}
+
 def find_order(a, n):
     """
     Find order for positive integer n and given integer a that satisfies gcd(a, n) = 1.
     """
+    
     if (a == 1) & (n == 1):
         # Exception Handeling : 1 is the order of of 1
+        branch_coverage["branch_6"] = True
+        print("branch_6")
         return 1
     if math.gcd(a, n) != 1:
+        branch_coverage["branch_7"] = True
+        print("branch_7")
         print ("a and n should be relative prime!")
         return -1
     for i in range(1, n):
+        branch_coverage["branch_8"] = True
+        print("branch_8")
         if pow(a, i) % n == 1:
+            branch_coverage["branch_9"] = True
+            print("branch_9")
             return i
+    branch_coverage["branch_10"] = True
+    print("branch_10")
     return -1
+
+def print_coverage():
+    for branch, hit in branch_coverage.items():
+        print(f"{branch} was {'hit' if hit else 'not hit'}")
+        
+print_coverage()

algorithms/maths/prime_check.py

@@ -1,17 +1,42 @@
+branch_coverage = {
+    "branch_1": False,  # n <= 1
+    "branch_2": False,  # n == 2 or n == 3
+    "branch_3": False,  # n % 2 == 0 or n % 3 == 0
+    "branch_4": False,  # while j * j <= n
+    "branch_5": False   # n % j == 0 or n % (j + 2) == 0
+}
 def prime_check(n):
     """Return True if n is a prime number
     Else return False.
     """
+    print(f"Checking {n}")  # Debugging statement
 
     if n <= 1:
+        branch_coverage["branch_1"] = True
+        print("branch_1")
         return False
+
     if n == 2 or n == 3:
+        branch_coverage["branch_2"] = True
+        print("branch_2")
         return True
     if n % 2 == 0 or n % 3 == 0:
+        branch_coverage["branch_3"] = True
+        print("branch_3")
         return False
     j = 5
     while j * j <= n:
+        branch_coverage["branch_4"] = True
+        print("branch_4")
         if n % j == 0 or n % (j + 2) == 0:
+            branch_coverage["branch_5"] = True
+            print("branch_5")
             return False
         j += 6
     return True
+
+def print_coverage():
+    for branch, hit in branch_coverage.items():
+        print(f"{branch} was {'hit' if hit else 'not hit'}")
+        
+print_coverage()

algorithms/maths/pythagoras.py

@@ -2,6 +2,13 @@
 Given the lengths of two of the three sides of a right angled triangle, this function returns the
 length of the third side.
 """
+branch_coverage = {
+    "branch_1": False,
+    "branch_2": False,
+    "branch_3": False,
+    "branch_4": False,
+    #"branch_5": False 
+}
 
 def pythagoras(opposite, adjacent, hypotenuse):
     """
@@ -10,11 +17,32 @@ def pythagoras(opposite, adjacent, hypotenuse):
     """
     try:
         if opposite == str("?"):
+            branch_coverage["branch_1"] = True
+            print("branch_1")
             return ("Opposite = " + str(((hypotenuse**2) - (adjacent**2))**0.5))
         if adjacent == str("?"):
+            branch_coverage["branch_2"] = True
+            print("branch_2")
             return ("Adjacent = " + str(((hypotenuse**2) - (opposite**2))**0.5))
         if hypotenuse == str("?"):
+            branch_coverage["branch_3"] = True
+            print("branch_3")
             return ("Hypotenuse = " + str(((opposite**2) + (adjacent**2))**0.5))
+        branch_coverage["branch_4"] = True
+        print("branch_4")
         return "You already know the answer!"
     except:
+        # branch_coverage["branch_5"] = True
+        # print("branch_5")
         raise ValueError("invalid argument(s) were given.")
+    
+def print_coverage():
+    for branch, hit in branch_coverage.items():
+        print(f"{branch} was {'hit' if hit else 'not hit'}")
+        
+print_coverage()
+
+# total = len(branch_coverage)
+#     reached_branches = sum(branch_coverage.values())
+#     percentage = (reached_branches/total)*100
+# print_coverage()

algorithms/search/interpolation_search.py

@@ -13,6 +13,15 @@
 
 from typing import List
 
+branch_coverage = {
+    "branch_60": False,
+    "branch_61": False,
+    "branch_62": False,
+    "branch_63": False,
+    "branch_64": False,
+
+}
+
 
 def interpolation_search(array: List[int], search_key: int) -> int:
     """
@@ -38,24 +47,36 @@ def interpolation_search(array: List[int], search_key: int) -> int:
 
     while (low <= high) and (array[low] <= search_key <= array[high]):
         # calculate the search position
+        branch_coverage["branch_60"] = True
         pos = low + int(((search_key - array[low]) *
                          (high - low) / (array[high] - array[low])))
 
         # search_key is found
         if array[pos] == search_key:
+            branch_coverage["branch_61"] = True
             return pos
 
         # if search_key is larger, search_key is in upper part
         if array[pos] < search_key:
+            branch_coverage["branch_62"] = True
             low = pos + 1
 
         # if search_key is smaller, search_key is in lower part
         else:
+            branch_coverage["branch_63"] = True
             high = pos - 1
-
+            
+    branch_coverage["branch_64"] = True
     return -1
 
+def print_coverage():
+    for branch, hit in branch_coverage.items():
+        print(f"{branch} was {'hit' if hit else 'not hit'}")
+        
+
 
 if __name__ == "__main__":
     import doctest
     doctest.testmod()
+print_coverage()
+

tests/test_search.py

@@ -139,13 +139,28 @@ def test_next_greatest_letter(self):
         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]
+        array = [0, 3, 5, 5, 9, 12, 12, 15, 16, 19, 20, 25]
+                 #, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100]
+        
+        # array = [0, 3, 5, 5, 9, 12, 12, 15, 16, 19, 20, 25]
         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))
+        
+        # self.assertEqual(-1, interpolation_search(array, 1))
+        # self.assertEqual(0, interpolation_search(array, 0))  # Found at the start
+        # self.assertEqual(interpolation_search(array, 12), 5)  # Found in the middle, first occurrence
+        # self.assertEqual(-1, interpolation_search(array, 110))  # Not found, above maximum
+        # self.assertEqual(interpolation_search(array, 55), 17)  # Found in the middle
+        # self.assertEqual(interpolation_search(array, 70), 20)  # Found, single value in range
+        # self.assertEqual(interpolation_search(array, 22), -1)  # Not found, above the range
+        # self.assertEqual(interpolation_search(array, 50), 16)  # Found, single value in range
+        # self.assertEqual(interpolation_search(array, 45), 15)  # Found, single value in range
+
+
 
 
 if __name__ == '__main__':

tests/test_strings.py

@@ -568,6 +568,7 @@ class TestFirstUniqueChar(unittest.TestCase):
     def test_first_unique_char(self):
         self.assertEqual(0, first_unique_char("leetcode"))
         self.assertEqual(2, first_unique_char("loveleetcode"))
+        self.assertEqual(-1, first_unique_char("aabb"))
 
 
 class TestRepeatSubstring(unittest.TestCase):