From ea63137215b24f5f3a0fa10cf29000ca229a6201 Mon Sep 17 00:00:00 2001 From: Fithi Teklom Date: Thu, 15 Oct 2026 22:07:45 +0100 Subject: [PATCH] Refactor Sprint 1 exercises --- .../calculateSumAndProduct.js | 20 ++++++---- .../findCommonItems/findCommonItems.js | 28 +++++++++++--- .../hasPairWithSum/hasPairWithSum.js | 27 +++++++++---- .../removeDuplicates/removeDuplicates.mjs | 38 ++++++------------- 4 files changed, 64 insertions(+), 49 deletions(-) diff --git a/Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js b/Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js index ce738c33..e49d8c15 100644 --- a/Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js +++ b/Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js @@ -9,26 +9,30 @@ * "product": 30 // 2 * 3 * 5 * } * - * Time Complexity: - * Space Complexity: - * Optimal Time Complexity: + * Time Complexity:O(n) — two loops each visit every number. + * Space Complexity: O(1) — uses a fixed number of variables. + * Optimal Time Complexity: O(n) — every number must be checked. * * @param {Array} 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; - } - let product = 1; for (const num of numbers) { + sum += num; product *= num; } - return { sum: sum, product: product, }; } + +/** + After Refactor + * Time Complexity: O(n) — one loop calculates both results. + * Space Complexity: O(1) — uses a fixed number of variables. + * Optimal Time Complexity: O(n) — every number must be checked. + */ diff --git a/Sprint-1/JavaScript/findCommonItems/findCommonItems.js b/Sprint-1/JavaScript/findCommonItems/findCommonItems.js index 5619ae5d..44e1f27a 100644 --- a/Sprint-1/JavaScript/findCommonItems/findCommonItems.js +++ b/Sprint-1/JavaScript/findCommonItems/findCommonItems.js @@ -1,14 +1,30 @@ /** * Finds common items between two arrays. * - * Time Complexity: - * Space Complexity: - * Optimal Time Complexity: + * Time Complexity: O(n * m), where as well as m referes to a size — checks each item in the first array against items in the second array. + * Space Complexity: O(n) — creates a filtered array and a Set. + * Optimal Time Complexity: O(n + m) — each array can be checked in linear time using a Set. * * @param {Array} firstArray - First array to compare * @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) => { + const secondSet = new Set(secondArray); + const commonItems = new Set(); + + for (const item of firstArray) { + if (secondSet.has(item)) { + commonItems.add(item); + } + } + + return [...commonItems]; +} + +/** + After Refactoring + * Time Complexity: O(n + m) — uses a Set to check for common items efficiently. + * Space Complexity: O(m + q) — stores items from the second array and the common items, where q is the number of unique matches. + * Optimal Time Complexity: O(n + m) — each array is processed in linear time. + */ diff --git a/Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js b/Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js index dd2901f6..d055c817 100644 --- a/Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js +++ b/Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js @@ -1,21 +1,32 @@ /** * 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²) — nested loops check pairs of numbers. + * Space Complexity: O(1) — uses only a fixed number of variables. + * Optimal Time Complexity:O(n) — a Set can find a matching pair in one pass, on average. * * @param {Array} numbers - Array of numbers to search through * @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; - } + const seen = new Set(); + for (const number of numbers) { + const needed = target - number; + + if (seen.has(needed)) { + return true; } + + seen.add(number); } + return false; } + +/* +After Refactoring + * Time Complexity: O(n) — checks each number once on average. + * Space Complexity: O(n) — stores numbers in a Set. + * Optimal Time Complexity: O(n) — one pass using a Set, on average. + */ diff --git a/Sprint-1/JavaScript/removeDuplicates/removeDuplicates.mjs b/Sprint-1/JavaScript/removeDuplicates/removeDuplicates.mjs index dc5f7711..25538fcf 100644 --- a/Sprint-1/JavaScript/removeDuplicates/removeDuplicates.mjs +++ b/Sprint-1/JavaScript/removeDuplicates/removeDuplicates.mjs @@ -1,36 +1,20 @@ /** * 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²),the nested loops may compare many items against one another. + * Space Complexity:O(n) — stores the unique items in a new array. + * Optimal Time Complexity: O(n) — a Set can check for duplicates in one pass, on average. * * @param {Array} inputSequence - Sequence to remove duplicates from * @returns {Array} New sequence with duplicates removed */ 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]); - } - } - - return uniqueItems; + return [...new Set(inputSequence)]; } + +/* +After Refactoring + *Time Complexity: O(n) — uses a Set, on average. + * Space Complexity: O(n) — stores unique items in a new collection. + * Optimal Time Complexity: O(n) — each input item must be checked. +*/ \ No newline at end of file