diff --git a/Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js b/Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js
index ce738c33..24bc1fc7 100644
--- a/Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js
+++ b/Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js
@@ -17,13 +17,18 @@
  * @returns {Object} Object containing running total and product
  */
 export function calculateSumAndProduct(numbers) {
-  let sum = 0;
-  for (const num of numbers) {
-    sum += num;
-  }
 
+
+  // 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.
+
+  
+  let sum = 0;
   let product = 1;
+
   for (const num of numbers) {
+    sum += num;
     product *= num;
   }
 
diff --git a/Sprint-1/JavaScript/findCommonItems/findCommonItems.js b/Sprint-1/JavaScript/findCommonItems/findCommonItems.js
index 5619ae5d..25b888bc 100644
--- a/Sprint-1/JavaScript/findCommonItems/findCommonItems.js
+++ b/Sprint-1/JavaScript/findCommonItems/findCommonItems.js
@@ -9,6 +9,16 @@
  * @param {Array} secondArray - Second array to compare
  * @returns {Array} Array containing unique common items
  */
-export const findCommonItems = (firstArray, secondArray) => [
-  ...new Set(firstArray.filter((item) => secondArray.includes(item))),
-];
+// export const findCommonItems = (firstArray, secondArray) => [
+//   ...new Set(firstArray.filter((item) => secondArray.includes(item))),
+// ];
+
+
+export const findCommonItems = (firstArray, secondArray) => {
+
+  // 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).
+
+  const set = new Set(secondArray);
+
+  return [... new Set(firstArray.filter(item => set.has(item)))]
+}
\ No newline at end of file
diff --git a/Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js b/Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js
index dd2901f6..6a4a2408 100644
--- a/Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js
+++ b/Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js
@@ -1,21 +1,23 @@
 /**
  * Find if there is a pair of numbers that sum to a given target value.
  *
- * Time Complexity:
- * Space Complexity:
- * Optimal Time Complexity:
+ * Time Complexity: O(n)
+ * Space Complexity: O(1)
+ * Optimal Time Complexity: O(n)
  *
  * @param {Array<number>} numbers - Array of numbers to search through
  * @param {number} target - Target sum to find
  * @returns {boolean} True if pair exists, false otherwise
  */
+
+//  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
+
 export function hasPairWithSum(numbers, target) {
   for (let i = 0; i < numbers.length; i++) {
-    for (let j = i + 1; j < numbers.length; j++) {
-      if (numbers[i] + numbers[j] === target) {
-        return true;
-      }
+    if (numbers[i] + numbers[i + 1] === target) {
+      return true
     }
   }
+
   return false;
-}
+}
\ No newline at end of file
diff --git a/Sprint-1/JavaScript/removeDuplicates/removeDuplicates.mjs b/Sprint-1/JavaScript/removeDuplicates/removeDuplicates.mjs
index dc5f7711..cdfc7f5f 100644
--- a/Sprint-1/JavaScript/removeDuplicates/removeDuplicates.mjs
+++ b/Sprint-1/JavaScript/removeDuplicates/removeDuplicates.mjs
@@ -1,34 +1,25 @@
 /**
  * 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)
+ * Space Complexity: O(n)
+ * Optimal Time Complexity: O(n)
  *
  * @param {Array} inputSequence - Sequence to remove duplicates from
  * @returns {Array} New sequence with duplicates removed
  */
 export function removeDuplicates(inputSequence) {
   const uniqueItems = [];
+  const seen = new Set();
 
   for (
     let currentIndex = 0;
     currentIndex < inputSequence.length;
     currentIndex++
   ) {
-    let isDuplicate = false;
-    for (
-      let compareIndex = 0;
-      compareIndex < uniqueItems.length;
-      compareIndex++
-    ) {
-      if (inputSequence[currentIndex] === uniqueItems[compareIndex]) {
-        isDuplicate = true;
-        break;
-      }
-    }
-    if (!isDuplicate) {
-      uniqueItems.push(inputSequence[currentIndex]);
+    if (!seen.has(inputSequence[currentIndex])) {
+      seen.add(inputSequence[currentIndex]);
+      uniqueItems.push(inputSequence[currentIndex])
     }
   }
 
diff --git a/Sprint-1/Python/calculate_sum_and_product/calculate_sum_and_product.py b/Sprint-1/Python/calculate_sum_and_product/calculate_sum_and_product.py
index cfd5cfdf..9c639734 100644
--- a/Sprint-1/Python/calculate_sum_and_product/calculate_sum_and_product.py
+++ b/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}
diff --git a/Sprint-1/Python/find_common_items/find_common_items.py b/Sprint-1/Python/find_common_items/find_common_items.py
index 478e2efc..50353e25 100644
--- a/Sprint-1/Python/find_common_items/find_common_items.py
+++ b/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
diff --git a/Sprint-1/Python/has_pair_with_sum/has_pair_with_sum.py b/Sprint-1/Python/has_pair_with_sum/has_pair_with_sum.py
index fe2da517..3f89feec 100644
--- a/Sprint-1/Python/has_pair_with_sum/has_pair_with_sum.py
+++ b/Sprint-1/Python/has_pair_with_sum/has_pair_with_sum.py
@@ -7,12 +7,22 @@ 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^2) because it loops twice to check for the possible pairs.
+    Space Complexity:   O(1) because no extra space is used in the process.
+    Optimal time complexity:    O(n) can be possible if sets are used.
     """
-    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):
+
+    #     for j in range(i + 1, numbers):
+    #         if numbers[i] + numbers[i + 1] == target_sum:
+    #             return True
+            
+    # return False
+
+    seen = set()
+
+    for num in numbers:
+        if target_sum - num in seen:
+            return True
+        seen.add(num)
     return False
diff --git a/Sprint-1/Python/remove_duplicates/remove_duplicates.py b/Sprint-1/Python/remove_duplicates/remove_duplicates.py
index c9fdbe80..9070c4e7 100644
--- a/Sprint-1/Python/remove_duplicates/remove_duplicates.py
+++ b/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