improve with caches

Author: delmorallopez

Sprint-2/improve_with_caches/fibonacci/fibonacci.py

@@ -1,4 +1,12 @@
-def fibonacci(n):
+
+
+def fibonacci(n, cache={}): # Add a cache parameter to store previously computed Fibonacci values
+    if n in cache: # Check if the Fibonacci value for n is already in the cache
+        return cache[n]
+
     if n <= 1:
         return n
-    return fibonacci(n - 1) + fibonacci(n - 2)
+
+    result = fibonacci(n - 1, cache) + fibonacci(n - 2, cache) # Recursive calls to compute Fibonacci values for n-1 and n-2, passing the cache to store results
+    cache[n] = result # Store the computed Fibonacci value for n in the cache before returning it
+    return result

Sprint-2/improve_with_caches/fibonacci/fibonacci_test.py

@@ -1,5 +1,4 @@
 import unittest
-
 from fibonacci import fibonacci
 
 class FibonacciTest(unittest.TestCase):

Sprint-2/improve_with_caches/making_change/making_change.py

@@ -1,32 +1,70 @@
-from typing import List
+from typing import List, Tuple, Dict
+from typing import List, Tuple, Dict
 
 
-def ways_to_make_change(total: int) -> int:
+def ways_to_make_change(total: int) -> int: 
     """
     Given access to coins with the values 1, 2, 5, 10, 20, 50, 100, 200, returns a count of all of the ways to make the passed total value.
 
     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])
+    return ways_to_make_change_helper( # Call the helper function with the total, the list of coin denominations, and an empty cache
+        total,
+        [200, 100, 50, 20, 10, 5, 2, 1],
+        cache={}
+    )
 
+from typing import List, Tuple, Dict
 
-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:
+
+def ways_to_make_change(total: int) -> int:
+    return ways_to_make_change_helper(
+        total,
+        [200, 100, 50, 20, 10, 5, 2, 1],
+        cache={}
+    )
+
+
+def ways_to_make_change_helper(
+    total: int,
+    coins: List[int],
+    cache: Dict[Tuple[int, Tuple[int, ...]], int]
+) -> int:
+
+    # Convert coins list to tuple so it can be used as dict key
+    key = (total, tuple(coins))
+
+    if key in cache:
+        return cache[key]
+
+    if total == 0:
+        return 1
+
+    if len(coins) == 0:
         return 0
 
     ways = 0
+
+    # Iterate through each coin denomination and count the number of ways to make change using that denomination 
+    # and the remaining coins
     for coin_index in range(len(coins)):
         coin = coins[coin_index]
         count_of_coin = 1
-        while coin * count_of_coin <= total:
+
+        while coin * count_of_coin <= total: # While the total value of the current coin denomination multiplied by the count of that coin is less than or equal to the total, we can continue to count ways to make change using that denomination
             total_from_coins = coin * count_of_coin
-            if total_from_coins == total:
+
+            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
+                ways += ways_to_make_change_helper( # 
+                    total - total_from_coins,
+                    coins[coin_index + 1:],
+                    cache
+                )
+
+            count_of_coin += 1 # Increment the count of the current coin denomination to check for the next possible combination of coins
+
+    cache[key] = ways
     return ways
+

Sprint-2/improve_with_caches/making_change/making_change_test.py

@@ -1,5 +1,4 @@
 import unittest
-
 from making_change import ways_to_make_change
 
 class MakingChangeTest(unittest.TestCase):