From 3a658038b1a3cbf694b9e82dc3f58071a77e585e Mon Sep 17 00:00:00 2001 From: Sara Tahir Date: Sat, 21 Feb 2026 12:11:00 +0000 Subject: [PATCH 1/3] Optimize fibonacci function by adding dictionary caching to speed up recursion. --- .../improve_with_caches/fibonacci/fibonacci.py | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/Sprint-2/improve_with_caches/fibonacci/fibonacci.py b/Sprint-2/improve_with_caches/fibonacci/fibonacci.py index 60cc667..fe3bc4f 100644 --- a/Sprint-2/improve_with_caches/fibonacci/fibonacci.py +++ b/Sprint-2/improve_with_caches/fibonacci/fibonacci.py @@ -1,4 +1,17 @@ +#initialising a dictionary to store a copy of what we already know or have already computed +#caching reduces the fibonacci time complexity from exponential to linear. +cache = {} + def fibonacci(n): - if n <= 1: + if n in cache: + return cache[n] + + if n <= 1: #when n is 0 or 1, we don’t need to calculate anything,just return th known value return n - return fibonacci(n - 1) + fibonacci(n - 2) + + result = fibonacci(n - 1) + fibonacci(n - 2) + + #saving result in our dict before returning + cache[n] = result + return result + From 6d1855e41a9bc57b81b636380e5979c59cc2e788 Mon Sep 17 00:00:00 2001 From: Sara Tahir Date: Sat, 21 Feb 2026 14:00:22 +0000 Subject: [PATCH 2/3] Implement memoisation + fix incorrect base case --- .../making_change/making_change.py | 22 ++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) 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..a9d60fa 100644 --- a/Sprint-2/improve_with_caches/making_change/making_change.py +++ b/Sprint-2/improve_with_caches/making_change/making_change.py @@ -1,5 +1,5 @@ from typing import List - +cache = {} def ways_to_make_change(total: int) -> int: """ @@ -11,22 +11,38 @@ def ways_to_make_change(total: int) -> int: def ways_to_make_change_helper(total: int, coins: List[int]) -> int: + """ Helper function for ways_to_make_change to avoid exposing the coins parameter to callers. """ - if total == 0 or len(coins) == 0: +#We found one valid way if its an exact match. + if total == 0: + return 1 +#base case no coins left but still have remaining total but no way to form it + if not coins: return 0 +#creating a cache key from our current prob, converting list to a tuple to make it hashable + key = (total, tuple(coins)) + if key in cache: + return cache[key] + ways = 0 +# Try using the current coin 1,2,3...times as long as we don't exceed the total. 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: + if total_from_coins == total: #if we get an exact match ++ on ways ways += 1 + +#remaining total and remaining coins after using the current one else: intermediate = ways_to_make_change_helper(total - total_from_coins, coins=coins[coin_index+1:]) ways += intermediate + count_of_coin += 1 + cache[key] = ways return ways + From d4407a9410dc9e7e3f19bb41ca538cf36f2be3d0 Mon Sep 17 00:00:00 2001 From: Sara Tahir Date: Sun, 22 Feb 2026 19:50:46 +0000 Subject: [PATCH 3/3] Refactor making_change to use index-based recursion instead of slicing --- .../making_change/making_change.py | 59 +++++++++++-------- 1 file changed, 35 insertions(+), 24 deletions(-) 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 a9d60fa..544f269 100644 --- a/Sprint-2/improve_with_caches/making_change/making_change.py +++ b/Sprint-2/improve_with_caches/making_change/making_change.py @@ -7,10 +7,11 @@ 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]) + coins = [200, 100, 50, 20, 10, 5, 2, 1] + return ways_to_make_change_helper(total, coins, 0) -def ways_to_make_change_helper(total: int, coins: List[int]) -> int: +def ways_to_make_change_helper(total: int, coins: List[int],start_index: int) -> int: """ Helper function for ways_to_make_change to avoid exposing the coins parameter to callers. @@ -18,31 +19,41 @@ def ways_to_make_change_helper(total: int, coins: List[int]) -> int: #We found one valid way if its an exact match. if total == 0: return 1 -#base case no coins left but still have remaining total but no way to form it - if not coins: +# No coins left to try as we moved past the end of the list + if start_index >= len(coins): return 0 -#creating a cache key from our current prob, converting list to a tuple to make it hashable - key = (total, tuple(coins)) + +# Cache key now uses (total, start_index) instead of hashing the whole coin list + key = (total, start_index) if key in cache: return cache[key] - ways = 0 -# Try using the current coin 1,2,3...times as long as we don't exceed the total. - 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: #if we get an exact match ++ on ways - ways += 1 - -#remaining total and remaining coins after using the current one - else: - intermediate = ways_to_make_change_helper(total - total_from_coins, coins=coins[coin_index+1:]) - ways += intermediate - - count_of_coin += 1 - cache[key] = ways + + # Try using the current coin 1,2,3... times as long as we don't exceed the total. + coin = coins[start_index] + count_of_coin = 1 + + while coin * count_of_coin <= total: + total_from_coins = coin * count_of_coin + + if total_from_coins == total: +# if exact match then one valid way + + ways += 1 + else: +# Remaining total, and move to the next coin (no slicing!) + intermediate = ways_to_make_change_helper( + total - total_from_coins, + coins, + start_index + 1 + ) + ways += intermediate + + count_of_coin += 1 + +# Also consider the case where we skip this coin entirely + ways += ways_to_make_change_helper(total, coins, start_index + 1) + + cache[key] = ways return ways -