Address PR feedback

Author: zohrehKazemianpour

Sprint-1/Python/calculate_sum_and_product/calculate_sum_and_product.py

@@ -12,20 +12,18 @@ def calculate_sum_and_product(input_numbers: List[int]) -> Dict[str, int]:
         "sum": 10, // 2 + 3 + 5
         "product": 30 // 2 * 3 * 5
     }
-    Time Complexity:
-    Space Complexity:
-    Optimal time complexity:
+    Time Complexity: O(2n) = O(n) - We iterate through the list twice (once for sum, once for product)
+    Space Complexity: O(1) - Only using constant extra space for variables
+    Optimal time complexity: O(n) - We can achieve O(n) by combining both loops into one single pass
     """
     # Edge case: empty list
     if not input_numbers:
         return {"sum": 0, "product": 1}
 
-    sum = 0
+    sum_value = 0
+    product_value = 1
     for current_number in input_numbers:
-        sum += current_number
+        sum_value += current_number
+        product_value *= current_number
 
-    product = 1
-    for current_number in input_numbers:
-        product *= current_number
-
-    return {"sum": sum, "product": product}
+    return {"sum": sum_value, "product": product_value}

Sprint-1/Python/find_common_items/find_common_items.py

@@ -9,13 +9,20 @@ def find_common_items(
     """
     Find common items between two arrays.
 
-    Time Complexity:
-    Space Complexity:
-    Optimal time complexity:
+    Time Complexity: O(n * m) - where n is the length of the first array and m is the length of the second array.
+                     We iterate through each element in the first array and for each element, we check if it exists
+                     in the second array using the 'in' operator, which takes O(m) time. We also check if the item
+                     is already in common_items using 'not in', which takes O(k) time where k is the size of common_items.
+    Space Complexity: O(k) - where k is the number of common items found. We store each common item in the list.
+    Optimal time complexity: O(n + m) - Using a hash set (dictionary/set) for the second sequence allows us to achieve
+                             linear time by avoiding the nested loop. This reduces the lookup from O(m) to O(1).
     """
+    # Create a set from the second sequence for O(1) lookups
+    second_set = set(second_sequence)
     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)
+
+    for item in first_sequence:
+        if item in second_set and item not in common_items:
+            common_items.append(item)
+
     return common_items

Sprint-1/Python/has_pair_with_sum/has_pair_with_sum.py

@@ -7,12 +7,20 @@ def has_pair_with_sum(numbers: List[Number], target_sum: Number) -> bool:
     """
     Find if there is a pair of numbers that sum to a target value.
 
-    Time Complexity:
-    Space Complexity:
-    Optimal time complexity:
+    Time Complexity: O(n²) - where n is the length of the input array. We use two nested loops, where the outer loop
+                     iterates through each element, and the inner loop iterates through all subsequent elements.
+                     In the worst case, we need to check all pairs.
+    Space Complexity: O(1) - We only use constant extra space for loop variables.
+    Optimal time complexity: O(n) - Using a hash set allows us to check if the complement (target_sum - current_number)
+                             exists in O(1) time, reducing the overall complexity from O(n²) to O(n) with one pass through the array.
     """
-    for i in range(len(numbers)):
-        for j in range(i + 1, len(numbers)):
-            if numbers[i] + numbers[j] == target_sum:
-                return True
+    # Optimised approach: Use a set to store seen numbers for O(1) lookups
+    seen_numbers = set()
+
+    for num in numbers:
+        complement = target_sum - num
+        if complement in seen_numbers:
+            return True
+        seen_numbers.add(num)
+
     return False

Sprint-1/Python/remove_duplicates/remove_duplicates.py

@@ -7,19 +7,20 @@ def remove_duplicates(values: Sequence[ItemType]) -> List[ItemType]:
     """
     Remove duplicate values from a sequence, preserving the order of the first occurrence of each value.
 
-    Time complexity:
-    Space complexity:
-    Optimal time complexity:
+    Time Complexity: O(n²) - where n is the length of the input sequence. For each element in the values sequence,
+                     we iterate through all existing items in unique_items to check if it's a duplicate.
+                     In the worst case, this requires checking all previous elements.
+    Space Complexity: O(k) - where k is the number of unique items. We store up to k items in the unique_items list.
+    Optimal time complexity: O(n) - Using a set to track seen items allows us to check for duplicates in O(1) time,
+                             reducing the overall complexity from O(n²) to O(n).
     """
+    # Optimised approach: Use a set to track seen items for O(1) lookups
+    seen_items = set()
     unique_items = []
 
     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 seen_items:
+            seen_items.add(value)
             unique_items.append(value)
 
     return unique_items