These are the implementations of the this part of assignment.

Author: gai93003

Sprint-1/Python/calculate_sum_and_product/calculate_sum_and_product.py

@@ -16,16 +16,20 @@ def calculate_sum_and_product(input_numbers: List[int]) -> Dict[str, int]:
     Space Complexity:
     Optimal time complexity:
     """
+
+    """
+        In this case, there is no changes in the functionality that can change the time complexity as the complexity is already O(n) and only extra space is used.
+
+        In this case, I can just make the code easier to read and cleaner.
+    """
     # Edge case: empty list
     if not input_numbers:
         return {"sum": 0, "product": 1}
 
     sum = 0
-    for current_number in input_numbers:
-        sum += current_number
-
     product = 1
     for current_number in input_numbers:
+        sum += current_number
         product *= current_number
 
     return {"sum": sum, "product": product}

Sprint-1/Python/find_common_items/find_common_items.py

@@ -13,9 +13,16 @@ def find_common_items(
     Space Complexity:
     Optimal time complexity:
     """
-    common_items: List[ItemType] = []
-    for i in first_sequence:
-        for j in second_sequence:
-            if i == j and i not in common_items:
-                common_items.append(i)
+
+    """ In this case, the time complexity is O(n * m), it will only become O(n^2) when the two arrays have equal lengths. This case easily be avoided by using a set to store the second sequence. When checking for a match in the set using item in second-set, this has a time complexity of O(1).
+
+    """
+    
+    second_set = set(second_sequence)
+    common_items = []
+
+    for item in first_sequence:
+
+        if item in second_set:
+            common_items.append(item)
     return common_items

Sprint-1/Python/has_pair_with_sum/has_pair_with_sum.py

@@ -11,8 +11,9 @@ def has_pair_with_sum(numbers: List[Number], target_sum: Number) -> bool:
     Space Complexity:
     Optimal time complexity:
     """
-    for i in range(len(numbers)):
-        for j in range(i + 1, len(numbers)):
-            if numbers[i] + numbers[j] == target_sum:
-                return True
+    for i in range(len(numbers) - 1):
+
+        if numbers[i] + numbers[i + 1] == target_sum:
+            return True
+            
     return False

Sprint-1/Python/remove_duplicates/remove_duplicates.py

@@ -11,15 +11,18 @@ def remove_duplicates(values: Sequence[ItemType]) -> List[ItemType]:
     Space complexity:
     Optimal time complexity:
     """
+
+    """
+    The time complexity in the new implementation is O(n) because we only loop and iterated through the array once. The use of set to add and check value for occurrence is O(1) which is the best Optimal time complexity
+    """
+
     unique_items = []
+    new_set = set()
 
     for value in values:
-        is_duplicate = False
-        for existing in unique_items:
-            if value == existing:
-                is_duplicate = True
-                break
-        if not is_duplicate:
+
+        if value not in new_set:
             unique_items.append(value)
+            new_set.add(value)
 
     return unique_items