From 410e893bcf8f3e144f2b5f3fabe9107116a4db68 Mon Sep 17 00:00:00 2001 From: JanefrancessC Date: Wed, 24 Jun 2026 18:04:42 +0100 Subject: [PATCH 1/4] feat: Optimise calculateSumAndProduct function --- .../calculateSumAndProduct.js | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js b/Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js index ce738c3..1e070ca 100644 --- a/Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js +++ b/Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js @@ -9,21 +9,22 @@ * "product": 30 // 2 * 3 * 5 * } * - * Time Complexity: - * Space Complexity: - * Optimal Time Complexity: + * Time Complexity: O(n) + * Space Complexity:O(1) + * Optimal Time Complexity:O(n) * * @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; + + // Initial code looped twice through the array, i.e. 2 operations (n + n) = O(2n)operations => O(n). Limiting the loop to just one operation makes it n operation => O(n). + // The space complexity is constant as the variables do not grow when the function is called. + for (const num of numbers) { + sum += num; product *= num; } From 69205b29c6cbe3c7e2244e02e6a3527f209c6955 Mon Sep 17 00:00:00 2001 From: JanefrancessC Date: Wed, 24 Jun 2026 18:24:32 +0100 Subject: [PATCH 2/4] feat: Optimise findCommonItems function and reduce complexity --- .../findCommonItems/findCommonItems.js | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/Sprint-1/JavaScript/findCommonItems/findCommonItems.js b/Sprint-1/JavaScript/findCommonItems/findCommonItems.js index 5619ae5..6dc77e2 100644 --- a/Sprint-1/JavaScript/findCommonItems/findCommonItems.js +++ b/Sprint-1/JavaScript/findCommonItems/findCommonItems.js @@ -1,14 +1,21 @@ /** * Finds common items between two arrays. * - * Time Complexity: - * Space Complexity: - * Optimal Time Complexity: + * Initial code has this and can be refactored for optimisation + * Time Complexity: O(nm) + * Space Complexity: O(n) + * Optimal Time Complexity: O(n + m) * * @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) => [ +// ...new Set(firstArray.filter((item) => secondArray.includes(item))), +// ]; +// The initial solution had an expensive operation of .includes(item) search on the secondArray, resulting in O(nm) time complexity. The optimised code stores the secondArray in a set and allows O(1) lookup and reduce the complexity to O(n+m) +export const findCommonItems = (firstArray, secondArray) => { + const secondSet = new Set(secondArray); + + return [...new Set(firstArray.filter((item) => secondSet.has(item)))]; +}; From 4cbe96b8d781219d439bc40412c23874ebd5763c Mon Sep 17 00:00:00 2001 From: JanefrancessC Date: Wed, 24 Jun 2026 20:34:11 +0100 Subject: [PATCH 3/4] feat: Optimise hasPairWithSum function --- .../JavaScript/hasPairWithSum/hasPairWithSum.js | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js b/Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js index dd2901f..97bac66 100644 --- a/Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js +++ b/Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js @@ -1,21 +1,24 @@ /** * 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^2) + * Space Complexity:O(1) + * Optimal Time Complexity: O(n) * * @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) { + const seenNumbers = new Set(); 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; - } + // initial solution iterates twice, having outer and inner loop which gives us a time complexity of O(n**2). To optimise this, using a set to store seen numbers, then check whether the complement(target - number) for each num in the array has been seen and in the set. This gives a complexity of O(n) + let complement = target - numbers[i]; + + if (seenNumbers.has(complement)) { + return true; } + seenNumbers.add(numbers[i]); } return false; } From efbf151743243b28fb554776cfecd32d0b2d30a5 Mon Sep 17 00:00:00 2001 From: JanefrancessC Date: Wed, 24 Jun 2026 20:49:44 +0100 Subject: [PATCH 4/4] feat: optimise removeDuplicates function to reduce time complexity --- .../removeDuplicates/removeDuplicates.mjs | 36 ++++++------------- 1 file changed, 11 insertions(+), 25 deletions(-) diff --git a/Sprint-1/JavaScript/removeDuplicates/removeDuplicates.mjs b/Sprint-1/JavaScript/removeDuplicates/removeDuplicates.mjs index dc5f771..cfb1215 100644 --- a/Sprint-1/JavaScript/removeDuplicates/removeDuplicates.mjs +++ b/Sprint-1/JavaScript/removeDuplicates/removeDuplicates.mjs @@ -1,36 +1,22 @@ /** * 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**2) + * 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 = []; - - 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]); + const seenItems = new Set(); + let result = []; + // The initial solution was a nested loop, with a time complexity of O(n**2). This was optimised by using a set to track seen items, thereby reducing the complexity to O(n) + for (const item of inputSequence) { + if (!seenItems.has(item)) { + seenItems.add(item); + result.push(item); } } - - return uniqueItems; + return result; }