correction

Author: pathywang

Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js

@@ -18,12 +18,10 @@
  */
 export function calculateSumAndProduct(numbers) {
   let sum = 0;
-  for (const num of numbers) {
-    sum += num;
-  }
-
   let product = 1;
+
   for (const num of numbers) {
+    sum += num
     product *= num;
   }
 
@@ -33,9 +31,8 @@ export function calculateSumAndProduct(numbers) {
   };
 }
 
-// For two loops, we have visit each element of array  in order to get the result
-// so time complexity is O (n) which means linear. 
-// Regarding space complexity, we only get one result
-// for sum and product no matter how long the array is.so it is O(1)(constant)
-// While time complexity is O(n), optimal time complexity should be O(n) because loop 
-// has to go each single element in array.
+// Time complexity is O(n) because we visit each element once.
+// Space complexity is O(1) because we use a fixed number of variables,
+// regardless of the length of the input array.
+// Optimal time complexity is O(n) because every element must be examined
+// to guarantee the correct sum and product.

Sprint-1/Python/find_common_items/find_common_items.py

@@ -9,14 +9,27 @@ def find_common_items(
     """
     Find common items between two arrays.
 
-    Time Complexity:O(nm)
-    Space Complexity:O(n+m)
-    Optimal time complexity:O(n+m)
-    which is the same as JavaScript const findCommonItems = (firstArray, secondArray) 
+     Approach:
+    - Convert the second sequence to a set for faster membership checks.
+    - Use a set to track items already added and avoid duplicates.
+    - Preserve the order of items as they appear in the first sequence.
+
+    Time Complexity: O(n + m) on average, because set lookups take O(1)
+    on average and we iterate through both sequences.
+
+    Space Complexity: O(n + m) as an upper bound for the sets and output.
+    More precisely, O(m + k), where k is the number of unique common items.
+
+    Optimal Time Complexity: O(n + m) on average, assuming hashable items
+    and constant-time set operations on average.
     """
+    second_items = 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)
+    seen_items = set()
+
+    for item in first_sequence:
+        if item in second_items and item not in seen_items:
+            common_items.append(item)
+            seen_items.add(item)
+
     return common_items