Glasgow | 25-SDC-Nov | Nataliia Volkova | Sprint 1 | Big-O notation and refactoring in Python tasks

Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js

@@ -16,19 +16,36 @@
  * @param {Array<number>} numbers - Numbers to process
  * @returns {Object} Object containing running total and product
  */
-export function calculateSumAndProduct(numbers) {
-  let sum = 0;
-  for (const num of numbers) {
-    sum += num;
-  }
+// export function calculateSumAndProduct(numbers) {
+//   let sum = 0;
+//   for (const num of numbers) {
+//     sum += num;
+//   }
+
+//   let product = 1;
+//   for (const num of numbers) {
+//     product *= num;
+//   }
+
+//   return {
+//     sum: sum,
+//     product: product,
+//   };
+// }
 
-  let product = 1;
-  for (const num of numbers) {
-    product *= num;
-  }
+// Refactored:
 
-  return {
-    sum: sum,
-    product: product,
-  };
+export function calculateSumAndProduct(numbers) {
+  const result = numbers.reduce(
+    (acc, num) => {
+      ((acc.sum += num), (acc.product *= num));
+      return acc;
+    },
+    { sum: 0, product: 1 },
+  );
+  return result;
 }
+
+//  * Time Complexity: O(n)
+//  * Space Complexity: O(1)
+//  * Optimal Time Complexity: O(n)

Sprint-1/JavaScript/findCommonItems/findCommonItems.js

@@ -9,6 +9,18 @@
  * @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) => {
+  let firstArr = new Set(firstArray);
+  let secondArr = new Set(secondArray);
+
+  return [...firstArr].filter((arr) => secondArr.has(arr));
+};
+
+//  * https://www.w3schools.com/js/js_set_methods.asp#mark_set_new
+//  * Time Complexity: O(m+n)
+//  * Space Complexity: O(m+n)
+//  * Optimal Time Complexity: O(m+n)

Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js

@@ -9,13 +9,32 @@
  * @param {number} target - Target sum to find
  * @returns {boolean} True if pair exists, false otherwise
  */
+// 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;
+//       }
+//     }
+//   }
+//   return false;
+// }
+
+// To solve this problem I used this source: https://medium.com/@bloodturtle/finding-pairs-in-an-array-that-sum-to-a-target-value-b553e8c357bb
+
 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;
-      }
+  let seen = new Set();
+  for (let num of numbers) {
+    let complement = target - num;
+    if (seen.has(complement)) {
+      return true;
     }
+    seen.add(num);
   }
   return false;
 }
+
+//  * Time Complexity: O(n)
+//  * Space Complexity: O(n)
+//  * Optimal Time Complexity: O(n)
+// This solution is optimal because it uses a hash set(based on hash table logic) for constant-time lookups and processes each element once.

Sprint-1/JavaScript/removeDuplicates/removeDuplicates.mjs

@@ -8,29 +8,38 @@
  * @param {Array} inputSequence - Sequence to remove duplicates from
  * @returns {Array} New sequence with duplicates removed
  */
-export function removeDuplicates(inputSequence) {
-  const uniqueItems = [];
+// export function removeDuplicates(inputSequence) {
+//   const uniqueItems = [];
+
+//   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]);
+//     }
+//   }
 
-  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]);
-    }
-  }
+//   return uniqueItems;
+// }
 
-  return uniqueItems;
+export function removeDuplicates(inputSequence) {
+  let noDuplicates = [...new Set(inputSequence)];
+  return noDuplicates;
 }
+
+//  * Time Complexity: O(n)
+//  * Space Complexity: O(n)
+//  * Optimal Time Complexity: O(n)

Sprint-1/Python/calculate_sum_and_product/calculate_sum_and_product.py

@@ -1,31 +1,51 @@
 from typing import Dict, List
 
 
-def calculate_sum_and_product(input_numbers: List[int]) -> Dict[str, int]:
-    """
-    Calculate the sum and product of integers in a list.
-
-    Note: the sum is every number added together
-    and the product is every number multiplied together
-    so for example: [2, 3, 5] would return
-    {
-        "sum": 10, // 2 + 3 + 5
-        "product": 30 // 2 * 3 * 5
-    }
-    Time Complexity:
-    Space Complexity:
-    Optimal time complexity:
-    """
-    # Edge case: empty list
+# def calculate_sum_and_product(input_numbers: List[int]) -> Dict[str, int]:
+#     """
+#     Calculate the sum and product of integers in a list.
+
+#     Note: the sum is every number added together
+#     and the product is every number multiplied together
+#     so for example: [2, 3, 5] would return
+#     {
+#         "sum": 10, // 2 + 3 + 5
+#         "product": 30 // 2 * 3 * 5
+#     }
+#     Time Complexity:
+#     Space Complexity:
+#     Optimal time complexity:
+#     """
+#     # 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:
+#         product *= current_number
+
+#     return {"sum": sum, "product": product}
+
+def calculate_sum_and_product(input_numbers: List[int]) -> Dict[str,int]:
     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:
-        product *= current_number
+
+    for num in input_numbers:
+        sum += num
+        product *= num
 
     return {"sum": sum, "product": product}
+
+#     """
+#     Time Complexity: O(n)
+#     Space Complexity: O(1)
+#     Optimal time complexity: O(n)
+#     """
+

Sprint-1/Python/find_common_items/find_common_items.py

@@ -3,19 +3,40 @@
 ItemType = TypeVar("ItemType")
 
 
+# def find_common_items(
+#     first_sequence: Sequence[ItemType], second_sequence: Sequence[ItemType]
+# ) -> List[ItemType]:
+#     """
+#     Find common items between two arrays.
+
+#     Time Complexity:
+#     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)
+#     return common_items
+
+
 def find_common_items(
-    first_sequence: Sequence[ItemType], second_sequence: Sequence[ItemType]
-) -> List[ItemType]:
+    first_sequence: Sequence[ItemType], second_sequence: Sequence[ItemType]) -> List[ItemType]:
     """
     Find common items between two arrays.
 
-    Time Complexity:
-    Space Complexity:
-    Optimal time complexity:
+    Time Complexity: O(n+m)
+    Space Complexity: O(m+k)
+    Optimal time complexity: O(n+m)
     """
-    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)
-    return common_items
+    set_1 = set(first_sequence)
+    set_2 = []
+
+    for seq in set_1:
+        if seq in second_sequence:
+            set_2.append(seq)
+    return set_2       
+
+
+

Sprint-1/Python/has_pair_with_sum/has_pair_with_sum.py

@@ -3,16 +3,31 @@
 Number = TypeVar("Number", int, float)
 
 
+# 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:
+#     """
+#     for i in range(len(numbers)):
+#         for j in range(i + 1, len(numbers)):
+#             if numbers[i] + numbers[j] == target_sum:
+#                 return True
+#     return False
+
 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.
+    set_1 = set(numbers)
+    result = []
 
-    Time Complexity:
-    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 num in numbers:
+        differ = target_sum - num
+        if differ in set_1:
+            return True
+        result.append(differ)
     return False
+
+#       Time Complexity: O(n)
+# #     Space Complexity: O(n)
+# #     Optimal time complexity: O(n)

Sprint-1/Python/remove_duplicates/remove_duplicates.py

@@ -1,25 +1,40 @@
 from typing import List, Sequence, TypeVar
+from collections import OrderedDict
 
 ItemType = TypeVar("ItemType")
 
 
+# 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:
+#     """
+#     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:
+#             unique_items.append(value)
+
+#     return unique_items
+
 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)
+    Space complexity: O(n)
+    Optimal time complexity: O(n)
     """
-    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:
-            unique_items.append(value)
-
-    return unique_items
+    return list(OrderedDict.fromkeys(values))
+
+# Used OrderedDict to create a dictionary with the list elements as keys (preserves order)
+# Then, convert it back to a list to remove duplicates 
+# https://www.w3resource.com/python-exercises/list-advanced/python-list-advanced-exercise-8.php#:~:text=The%20Python%20OrderedDict.,order%20of%20the%20remaining%20elements.