diff --git a/Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js b/Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js index ce738c3..6d49388 100644 --- a/Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js +++ b/Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js @@ -9,24 +9,24 @@ * "product": 30 // 2 * 3 * 5 * } * - * Time Complexity: - * Space Complexity: - * Optimal Time Complexity: + * Time Complexity:O(2n) originall have this as using 2 separate loops + * Space Complexity:O(1) no extra space used that rows with input + * Optimal Time Complexity:O(n) must at least visit each number once * * @param {Array} numbers - Numbers to process * @returns {Object} Object containing running total and product */ + +// here we are using 2 loops one for sum and other for product +// but we can do it only in one loop so code will be more simple and faster + 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, diff --git a/Sprint-1/JavaScript/findCommonItems/findCommonItems.js b/Sprint-1/JavaScript/findCommonItems/findCommonItems.js index 5619ae5..c07b89b 100644 --- a/Sprint-1/JavaScript/findCommonItems/findCommonItems.js +++ b/Sprint-1/JavaScript/findCommonItems/findCommonItems.js @@ -1,14 +1,25 @@ /** * Finds common items between two arrays. * - * Time Complexity: - * Space Complexity: - * Optimal Time Complexity: + * Time Complexity:O(n+m) it build set and loop through arrays once + * Space Complexity: store second array in set + * Optimal Time Complexity:O(m+n) * * @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))), +// ]; +// Refactored to use a Set for faster lookups, making the code more efficient +export const findCommonItems = (firstArray, secondArray) => { + const secondArraySet = new Set(secondArray); + const resultSet = new Set(); + for (const element of firstArray) { + if (secondArraySet.has(element)) { + resultSet.add(element); + } + } + return [...resultSet]; +}; diff --git a/Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js b/Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js index dd2901f..9631c57 100644 --- a/Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js +++ b/Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js @@ -1,21 +1,35 @@ /** * 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(n2) the function use 2 nested loop + * Space Complexity:o(1)no additional significant memory used + * Optimal Time Complexity: O(n) — in the refactored version using a Set for lookups * * @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; +// } +// } +// } +// return false; +// } + 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 numbersNeeded = new Set(); // stores numbers we've already seen + + for (const num of numbers) { + const requiredNumber = target - num; + if (numbersNeeded.has(requiredNumber)) { + return true; // found a pair! } + numbersNeeded.add(num); // remember current number } - return false; + + return false; // no pair found } diff --git a/Sprint-1/Python/remove_duplicates/remove_duplicates.py b/Sprint-1/Python/remove_duplicates/remove_duplicates.py index c9fdbe8..b5a5f08 100644 --- a/Sprint-1/Python/remove_duplicates/remove_duplicates.py +++ b/Sprint-1/Python/remove_duplicates/remove_duplicates.py @@ -3,23 +3,32 @@ 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. +# 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 = [] +# Time complexity:O(n²) Quadratic The outer loop runs n times, and for each value, the inner loop also runs up to n times. +# Space complexity:O(n) store n elements in worst possible case +# Optimal time complexity: O(n) can be improved useing set +# """ +# 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) +# 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 unique_items +def remove_duplicates(values: Sequence[ItemType]) -> List[ItemType]: + unique_element= set() # for unique element + order_element =[] # to order maintain + for value in values: + if value not in unique_element: + unique_element.add(value) + order_element.append(value) + return order_element \ No newline at end of file diff --git a/Sprint-2/improve_with_caches/fibonacci/fibonacci.py b/Sprint-2/improve_with_caches/fibonacci/fibonacci.py index 60cc667..912d94b 100644 --- a/Sprint-2/improve_with_caches/fibonacci/fibonacci.py +++ b/Sprint-2/improve_with_caches/fibonacci/fibonacci.py @@ -1,4 +1,11 @@ +cache = {} + def fibonacci(n): + if(n) in cache: + return cache[n] if n <= 1: return n - return fibonacci(n - 1) + fibonacci(n - 2) + + result = fibonacci(n - 1) + fibonacci(n - 2) + cache[n] = result + return result diff --git a/Sprint-2/improve_with_caches/making_change/making_change.py b/Sprint-2/improve_with_caches/making_change/making_change.py index 255612e..1670605 100644 --- a/Sprint-2/improve_with_caches/making_change/making_change.py +++ b/Sprint-2/improve_with_caches/making_change/making_change.py @@ -1,4 +1,4 @@ -from typing import List +from typing import Dict, List, Tuple def ways_to_make_change(total: int) -> int: @@ -7,26 +7,34 @@ def ways_to_make_change(total: int) -> int: For instance, there are two ways to make a value of 3: with 3x 1 coins, or with 1x 1 coin and 1x 2 coin. """ - return ways_to_make_change_helper(total, [200, 100, 50, 20, 10, 5, 2, 1]) + cache: Dict[Tuple[int, int], int] = {} # Initialize cache + return ways_to_make_change_helper(total, [200, 100, 50, 20, 10, 5, 2, 1], cache, 0) -def ways_to_make_change_helper(total: int, coins: List[int]) -> int: +def ways_to_make_change_helper(total: int, coins: List[int], cache: Dict[Tuple[int, int], int], coin_index: int) -> int: """ Helper function for ways_to_make_change to avoid exposing the coins parameter to callers. """ - if total == 0 or len(coins) == 0: + if total == 0: + return 1 + if total < 0 or coin_index >= len(coins): return 0 + + + # Check cache + key = (total, coin_index) + if key in cache: + return cache[key] ways = 0 - for coin_index in range(len(coins)): - coin = coins[coin_index] - count_of_coin = 1 - while coin * count_of_coin <= total: - total_from_coins = coin * count_of_coin - if total_from_coins == total: - ways += 1 - else: - intermediate = ways_to_make_change_helper(total - total_from_coins, coins=coins[coin_index+1:]) - ways += intermediate - count_of_coin += 1 + coin = coins[coin_index] + count_of_coin = 1 + while coin * count_of_coin <= total: + remaining = total - coin * count_of_coin + ways += ways_to_make_change_helper(remaining, coins, cache, coin_index + 1) + count_of_coin += 1 + + ways += ways_to_make_change_helper(total, coins, cache, coin_index + 1) + + cache[key] = ways # Store result in cache return ways