West Midlands | 25-SDC-July | Gabriel Deng | Sprint 1 | Analyse and refactor functions

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;
   }
 

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)))]
+}

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;
-}
+}

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])
     }
   }
 

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

@@ -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

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