Skip to content

WestMidlands| SDC NOV 2025 |Sara Tahir| Sprint 2 | Improve with caches #119

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
SaraTahir28 wants to merge 3 commits into
base: main
Choose a base branch
from
Open

WestMidlands| SDC NOV 2025 |Sara Tahir| Sprint 2 | Improve with caches #119

Show file tree
Hide file tree
Changes from 2 commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
3a65803
Optimize fibonacci function by adding dictionary caching to speed up …
SaraTahir28 Feb 21, 2026
6d1855e
Implement memoisation + fix incorrect base case
SaraTahir28 Feb 21, 2026
d4407a9
Refactor making_change to use index-based recursion instead of slicing
SaraTahir28 Feb 22, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
17 changes: 15 additions & 2 deletions Sprint-2/improve_with_caches/fibonacci/fibonacci.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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

22 changes: 19 additions & 3 deletions Sprint-2/improve_with_caches/making_change/making_change.py
View file
Open in desktop
Copy link
Copy Markdown

@cjyuan cjyuan Feb 22, 2026 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Array creation is a relatively costly operation.

From line 42, we know coins can only be one of the following 9 arrays:

[200, 100, 50, 20, 10, 5, 2, 1]
[100, 50, 20, 10, 5, 2, 1]
[50, 20, 10, 5, 2, 1]
...
[1]
[]

We could further improve the performance if we can

  • avoid repeatedly creating the same sub-arrays at line 42 (e.g. use another cache), and
  • create key as (total, a_unique_integer_identifying_the_subarray) instead of as (total, tuple of coins)
    • There are only a small number of different subarrays. We can easily assign each subarray a unique integer.

Copy link
Copy Markdown
Author

@SaraTahir28 SaraTahir28 Feb 22, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

  1. Thanks for the suggestion . I’ve updated the implementation so I no longer slice the coins list. Instead, I pass a start_index through the recursion, which avoids creating new subarrays entirely.
  2. I also switched the cache key to (total, start_index) rather than (total, tuple(coins)). This gives each of the 9 possible sub‑arrays a unique integer “identity” automatically, without needing a separate mapping
  3. This keeps the logic the same but removes the repeated list allocations and makes the memoisation faster and cheaper.

Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
from typing import List

cache = {}

def ways_to_make_change(total: int) -> int:
"""
Expand All @@ -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

Loading