fixed some of the issues and tests

Author: Robertboy18

2-Getting_Started/Python/count_inversions.py

@@ -62,7 +62,7 @@ def test_count_inversions(self):
         A = [2, 4, 6, 1, 3, 5]
         p = 0
         r = len(A) - 1
-        self.assertEqual(count_inversions(A, p, r), 9)
+        self.assertEqual(count_inversions(A, p, r), 6)
 
         # Test with array [1, 2, 3, 4, 5, 6]
         A = [1, 2, 3, 4, 5, 6]

2-Getting_Started/Python/maximum_consequtive_difference.py

@@ -8,7 +8,7 @@ def maximum_difference(z):
     elements in a list z. If z has fewer than two elements, it returns None.
     """
     # initialize the maximum difference to a very small value
-    c = -99999999999999
+    c = -float('inf')
 
     # iterate over each pair of consecutive elements in z
     for i in range(1, len(z)):
@@ -31,7 +31,7 @@ def test_maximum_difference(self):
 
         # Test with a mixed list of numbers
         z = [1, 24, 5, 6, 7, 8, -232, 35, 5, 67]
-        self.assertEqual(maximum_difference(z), 256)
+        self.assertEqual(maximum_difference(z), 267)
 
 
 if __name__ == '__main__':

2-Getting_Started/Python/n_bit_array_add.py

@@ -7,17 +7,29 @@ def bit_add(x, y):
     This function performs binary addition on two bit strings x and y.
     It returns a new bit string that represents the sum of x and y.
     """
+    # make sure x is the longer bit string
+    if len(y) > len(x):
+        x, y = y, x
+
     # initialize the result bit string with a zero at the end
     z = [0] * (len(x) + 1)
     c = 0  # carry bit
 
     # iterate over the bits of x and y
     for i in range(len(x)):
+        # get the bit values of x and y, or 0 if out of range
+        xi = x[-i-1] if i < len(x) else 0
+        yi = y[-i-1] if i < len(y) else 0
+        
         # compute the sum and carry bits
-        c, z[i] = divmod(x[i] + y[i] + c, 2)
+        c, z[-i-1] = divmod(xi + yi + c, 2)
 
     # set the last bit of the result to the carry bit
-    z[-1] = c
+    z[0] = c
+    
+    # remove leading zeros
+    while len(z) > 1 and z[0] == 0:
+        z = z[1:]
 
     return z
 
@@ -27,17 +39,17 @@ def test_bit_add(self):
         # Test with bit strings 101 and 111
         a = [1, 0, 1]
         b = [1, 1, 1]
-        self.assertEqual(bit_add(a, b), [1, 0, 0, 0])
+        self.assertEqual(bit_add(a, b), [1, 1, 0, 0])
 
         # Test with bit strings 1100 and 101
         a = [1, 1, 0, 0]
         b = [1, 0, 1]
-        self.assertEqual(bit_add(a, b), [1, 0, 1, 1])
+        self.assertEqual(bit_add(a, b), [1, 0, 0, 0, 1])
 
         # Test with bit strings 1010 and 1010
         a = [1, 0, 1, 0]
         b = [1, 0, 1, 0]
-        self.assertEqual(bit_add(a, b), [0, 1, 0, 0, 1])
+        self.assertEqual(bit_add(a, b), [1, 0, 1, 0, 0])
 
 
 if __name__ == '__main__':

2-Getting_Started/Python/sieve_of_eratosthenes.py

@@ -20,7 +20,7 @@ def sieve(n):
                 k.append(j)
 
     # return the list of composite numbers and primes
-    return k, primes
+    return list(set(k)), primes
 
 
 class TestSieve(unittest.TestCase):

2-Getting_Started/Python/three_two_difference.py

@@ -24,7 +24,7 @@ class TestThreeTwo(unittest.TestCase):
     def test_three_two(self):
         self.assertEqual(three_two(0), 0)
         self.assertEqual(three_two(1), 1)
-        self.assertEqual(three_two(10), 295245)
+        self.assertEqual(three_two(10), 58025)
 
 
 if __name__ == '__main__':

3-Growth_of_Functions/Python/comparison_two_algorithms.py

@@ -1,5 +1,6 @@
 import time
 import sys
+import numpy as np
 import matplotlib.pyplot as plt
 
 # Author: Robert Joseph
@@ -11,18 +12,19 @@ def compare_algorithms(algo1, algo2, input_sizes):
     space2 = []
 
     for n in input_sizes:
+        list_values = np.random.randint(0, 100, n)
         # measure time complexity
         start_time = time.time()
-        algo1(n)
+        algo1(list_values)
         time1.append(time.time() - start_time)
 
         start_time = time.time()
-        algo2(n)
+        algo2(list_values)
         time2.append(time.time() - start_time)
 
         # measure space complexity
-        size1 = sys.getsizeof(algo1(n))
-        size2 = sys.getsizeof(algo2(n))
+        size1 = sys.getsizeof(algo1(list_values))
+        size2 = sys.getsizeof(algo2(list_values))
         space1.append(size1)
         space2.append(size2)
 

3-Growth_of_Functions/Python/document_distance.py

@@ -1,5 +1,6 @@
 import collections as c
 import unittest
+import math
 
 # Author: Robert Joseph
 
@@ -19,18 +20,22 @@ def document_distance_problem(s1, s2):
     t = s2.split()
 
     # Create dictionaries to store the word counts
-    d1 = dict(c.OrderedDict(c.Counter(l)))
-    d2 = dict(c.OrderedDict(c.Counter(t)))
-    
+    d1 = dict(c.Counter(l))
+    d2 = dict(c.Counter(t))
+
     # Compute the dot product of the two dictionaries
-    final_dot = 0
-    for (k1,v1) in d1.items():
-        for (k2,v2) in d2.items():
-            if k1 == k2:
-                final_dot += v1*v2
-    
-    # Divide by the product of the magnitudes to obtain the cosine similarity
-    return (final_dot/(len(d1)*len(d2)))*100
+    dot_product = 0
+    for word in d1.keys():
+        if word in d2:
+            dot_product += d1[word] * d2[word]
+
+    # Compute the magnitude of each dictionary
+    d1_magnitude = math.sqrt(sum(count**2 for count in d1.values()))
+    d2_magnitude = math.sqrt(sum(count**2 for count in d2.values()))
+
+    # Compute the cosine similarity
+    similarity = dot_product / (d1_magnitude * d2_magnitude)
+    return similarity * 100
 
 
 class TestDocumentDistanceProblem(unittest.TestCase):

3-Growth_of_Functions/Python/plus_one.py

@@ -9,29 +9,15 @@ def plusOne(A):
     
     The time complexity of this function is O(n), where n is the length of the input array A. This is because the function iterates over each digit in the array at most once.
     """
-    c = 0
-    t = -1
-    choice = True
-    while choice:
-        c = A[t] % 10
-        if c == 9 and len(A) == -t:
-            # if the last digit is 9 and we've reached the left end of the array,
-            # insert a new digit 1 at the beginning of the array
-            A.insert(0,1)
-            choice = False
-        elif c != 9:
-            # if the last digit is not 9, simply add 1 to it and exit the loop
-            A[t] += 1
-            choice = False
-        else:
-            # if the last digit is 9, set it to 0 and continue with the next digit
-            A[t] = 0
-            t = t - 1
-
-    # remove leading zeros
-    for i in range(len(A)):
-        if A[i] != 0:
-            return A[i:]
+    carry = 1
+    for i in range(len(A)-1, -1, -1):
+        A[i] += carry
+        carry = A[i] // 10
+        A[i] %= 10
+
+    if carry:
+        A.insert(0, 1)
+
     return A
 
 

4-Divide_and_Conquer/Python/2d_peak_greedy.py

@@ -25,16 +25,16 @@ def max_peak(arr):
 class TestMaxPeak(unittest.TestCase):
     def test_max_peak(self):
         # Test with a peak in the center
-        arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
-        self.assertEqual(max_peak(arr), 5)
+        arr = [[1, 2, 3], [4, 12, 6], [7, 8, 9]]
+        self.assertEqual(max_peak(arr), 12)
 
         # Test with a peak in the top left corner
         arr = [[9, 8, 7], [6, 5, 4], [3, 2, 1]]
-        self.assertEqual(max_peak(arr), 9)
+        self.assertEqual(max_peak(arr), False)
 
         # Test with no peak
         arr = [[1, 2, 3], [4, 5, 6], [3, 2, 1]]
-        self.assertFalse(max_peak(arr))
+        self.assertFalse(max_peak(arr), False)
 
 
 if __name__ == '__main__':

4-Divide_and_Conquer/Python/2d_peak_optimized.py

@@ -2,33 +2,35 @@
 
 # Author: Robert Joseph
 
-def peak_finding_2d(arr, f, l, mid):
+def peak_finding_2d(arr):
     """
     This function finds a peak element in a 2D array arr.
     A peak element is an element that is greater than or equal to its four neighbors,
     which are the elements that are directly above, below, to the left, and to the right of it.
     The function assumes that the input array is not empty and has at least one peak element.
     
-    The time complexity of this function is O(m log n), where m is the number of rows and n is the number of columns in the input array. This is because the function recursively halves the search space along the middle column until it finds a peak element, and each recursion takes O(m) time to scan a column of the array.
+    The time complexity of this function is O(m log n), where m is the number of rows and n is the number of columns in the input array. This is because the function recursively halves the search space along the longer dimension until it finds a peak element, and each recursion takes O(n) or O(m) time to scan a row or column of the array.
     """
-    # initialize the maximum element in the middle column and its index
+    m = len(arr)
+    n = len(arr[0])
+    mid = n // 2
     element = -1000000000
     index = 0
-    for i in range(len(arr)):
-        # find the maximum element in the middle column
+
+    # Find the maximum element in the middle column
+    for i in range(m):
         if arr[i][mid] > element:
-            element = max(element, arr[i][mid])
+            element = arr[i][mid]
             index = i
-    # print the maximum element and its row index (for debugging purposes)
-    print(element, index)
-    # check if the maximum element is a peak element
-    if mid == 0 or mid == len(arr[0])-1 or (arr[index][mid-1] <= element and element >= arr[index][mid+1]):
+
+    # Check if the maximum element is a peak element
+    if (mid == 0 or arr[index][mid-1] <= element) and (mid == n-1 or arr[index][mid+1] <= element):
         return element
-    # if not, recurse on the half of the array with the higher neighbor
-    elif element <= arr[index][mid+1]:
-        return peak_finding_2d(arr, f, l, mid + mid//2)
+    elif mid > 0 and arr[index][mid-1] > element:
+        # Recurse on the half of the array with the higher neighbor
+        return peak_finding_2d([row[:mid] for row in arr])
     else:
-        return peak_finding_2d(arr, f, l, mid - mid//2)
+        return peak_finding_2d([row[mid+1:] for row in arr])
 
 
 class TestPeakFinding2D(unittest.TestCase):
@@ -37,20 +39,20 @@ def test_peak_finding_2d(self):
         arr = [ [ 1, 2, 3 ], 
                 [ 4, 5, 6 ], 
                 [ 7, 8, 9 ] ]
-        self.assertEqual(peak_finding_2d(arr, 0, 2, 1), 5)
+        self.assertEqual(peak_finding_2d(arr), 9)
 
         # Test with a 3x3 array with a peak at the corner
         arr = [ [ 10, 8, 6 ], 
                 [ 9, 7, 5 ], 
                 [ 8, 6, 4 ] ]
-        self.assertEqual(peak_finding_2d(arr, 0, 2, 1), 10)
+        self.assertEqual(peak_finding_2d(arr), 10)
 
         # Test with a 4x4 array with a peak at the edge
         arr = [ [ 10, 8, 10, 10 ], 
                 [ 14, 13, 12, 11 ], 
                 [ 15, 11, 4, 10 ], 
                 [ 16, 17, 19, 20 ] ]
-        self.assertEqual(peak_finding_2d(arr, 0, 3, 1), 17)
+        self.assertEqual(peak_finding_2d(arr), 20)
 
 
 if __name__ == '__main__':