Memoization to Optimize Recursion in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a memo dictionary for caching results.

DSA Python

def fib(n, [1]):
    if n <= 1:
        return n
    if n in memo:
        return memo[n]
    memo[n] = fib(n-1, memo) + fib(n-2, memo)
    return memo[n]

memo = {}
print(fib(5, memo))

Drag options to blanks, or click blank then click option'

Amemo

Bcache

Cstore

Ddict

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different parameter name than the memo dictionary.

Not passing the memo dictionary in recursive calls.

The memo dictionary is passed as 'memo' to cache computed Fibonacci values.

2fill in blank

medium

Complete the code to check if the result is already cached.

DSA Python

def fib(n, memo):
    if n <= 1:
        return n
    if [1] in memo:
        return memo[n]
    memo[n] = fib(n-1, memo) + fib(n-2, memo)
    return memo[n]

Drag options to blanks, or click blank then click option'

Acache

Bmemo

Cfib

Dn

Attempts:

3 left

💡 Hint

Common Mistakes

Checking if 'memo' or 'cache' is in memo instead of 'n'.

Using the function name instead of the key.

We check if 'n' is a key in the memo dictionary to return cached results.

3fill in blank

hard

Fix the error in the recursive call to use memoization correctly.

DSA Python

def fib(n, memo):
    if n <= 1:
        return n
    if n in memo:
        return memo[n]
    memo[n] = fib(n-1, [1]) + fib(n-2, memo)
    return memo[n]

Drag options to blanks, or click blank then click option'

Amemo

Bdict

Ccache

Dn

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the wrong variable instead of the memo dictionary.

Not passing the memo dictionary in one of the recursive calls.

The memo dictionary must be passed in all recursive calls to cache results properly.

4fill in blank

hard

Fill both blanks to create a memoized factorial function.

DSA Python

def factorial(n, [1]):
    if n == 0:
        return 1
    if n in [2]:
        return memo[n]
    memo[n] = n * factorial(n-1, memo)
    return memo[n]

memo = {}
print(factorial(5, memo))

Drag options to blanks, or click blank then click option'

Amemo

Bcache

Dstore

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for the memo dictionary in parameter and inside the function.

Not checking the memo dictionary before recursive call.

The memo dictionary is named 'memo' and used consistently as parameter and inside the function.

5fill in blank

hard

Fill all three blanks to create a memoized function that sums numbers up to n.

DSA Python

def sum_to_n(n, [1]):
    if n == 0:
        return 0
    if n in [2]:
        return memo[n]
    memo[n] = n + sum_to_n(n-1, [3])
    return memo[n]

memo = {}
print(sum_to_n(5, memo))

Drag options to blanks, or click blank then click option'

Amemo

Dcache

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for the memo dictionary in different places.

Not passing the memo dictionary in recursive calls.

The memo dictionary is consistently named 'memo' and passed as parameter and used inside the function.

Practice

1. What is the main purpose of using memoization in recursive functions?

easy

A. To replace recursion with iteration

B. To make the function run slower by adding extra steps

C. To store results of expensive function calls and reuse them

D. To increase the memory usage without any benefit

Solution

1. Step 1: Understand what memoization does

   Memoization saves the results of function calls so that if the same inputs occur again, the function can return the saved result instead of recalculating.

2. Step 2: Identify the benefit of memoization

   This saves time by avoiding repeated calculations, making recursive functions faster.

3. Final Answer:

   To store results of expensive function calls and reuse them -> Option C

4. Quick Check:

   Memoization = Store and reuse results [OK]

Hint: Memoization saves repeated work by caching results [OK]

Common Mistakes:

• Thinking memoization slows down the function
• Confusing memoization with converting recursion to loops
• Believing memoization always increases memory without benefit

2. Which of the following is the correct way to define a memo dictionary inside a recursive function in Python?

easy

A. def fib(n, memo={}):

B. def fib(n, memo=None): memo = {}

C. def fib(n, memo=[]):

D. def fib(n, memo=0):

Solution

1. Step 1: Understand default mutable arguments problem

   Using a mutable default argument like a dictionary directly can cause unexpected behavior because the same dictionary is shared across calls.

2. Step 2: Use None as default and initialize inside

   Setting memo=None and then initializing memo = {} inside the function avoids this problem and is the correct pattern.

3. Final Answer:

   def fib(n, memo=None): memo = {} -> Option B

4. Quick Check:

   Use None default and initialize dict inside [OK]

Hint: Use None default and create dict inside function [OK]

Common Mistakes:

• Using mutable default arguments directly
• Using list instead of dictionary for memo
• Setting memo default to 0 which is invalid

3. What will be the output of the following code?

def fib(n, memo=None):
    if memo is None:
        memo = {}
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fib(n-1, memo) + fib(n-2, memo)
    return memo[n]

print(fib(5))

medium

A. 8

B. None

C. 3

D. 5

Solution

1. Step 1: Trace fib(5) with memoization

   fib(5) = fib(4) + fib(3), fib(4) = fib(3) + fib(2), and so on. Using memoization avoids repeated calls.

2. Step 2: Calculate fib(5)

   fib(0)=0, fib(1)=1, fib(2)=1, fib(3)=2, fib(4)=3, fib(5)=5.

3. Final Answer:

   5 -> Option D

4. Quick Check:

   fib(5) = 5 [OK]

Hint: Remember fib(5) = 5 in Fibonacci sequence [OK]

Common Mistakes:

• Confusing fib(5) with fib(6)
• Ignoring memo and recalculating values
• Returning None due to missing return

4. Identify the error in this memoized factorial function and select the fix:

def factorial(n, memo=None):
    if memo is None:
        memo = {}
    if n == 0:
        return 1
    if n in memo:
        return memo[n]
    memo[n] = n * factorial(n-1)
    return memo[n]

medium

A. Add memo argument in recursive call: factorial(n-1, memo)

B. Change base case to n == 1

C. Initialize memo as a list instead of dict

D. Remove memo dictionary completely

Solution

1. Step 1: Check recursive call parameters

   The recursive call factorial(n-1) misses passing memo, so memo is reset each time, losing stored results.

2. Step 2: Fix by passing memo in recursive call

   Change to factorial(n-1, memo) to keep using the same memo dictionary.

3. Final Answer:

   Add memo argument in recursive call: factorial(n-1, memo) -> Option A

4. Quick Check:

   Pass memo in recursion to keep cache [OK]

Hint: Always pass memo in recursive calls [OK]

Common Mistakes:

• Forgetting to pass memo in recursive call
• Changing base case unnecessarily
• Using list instead of dictionary for memo

5. You want to optimize a recursive function that calculates the number of ways to climb n stairs, taking 1 or 2 steps at a time. Which memoization approach below correctly avoids redundant calculations and handles edge cases?

hard

A. Use memo=None default, initialize inside, pass memo in recursive calls, and handle base cases for n=0 and n=1

B. Use a default mutable argument dictionary and update it inside the function

C. Do not use memoization; rely on simple recursion for clarity

D. Use a global dictionary outside the function to store results and pass n only

Solution

1. Step 1: Understand memoization best practice

   Using memo=None default and initializing inside avoids shared mutable defaults and ensures fresh memo per call.

2. Step 2: Pass memo in recursive calls and handle base cases

   Passing memo keeps cache consistent. Base cases n=0 (1 way) and n=1 (1 way) prevent infinite recursion and define correct results.

3. Final Answer:

   Use memo=None default, initialize inside, pass memo in recursion, handle base cases -> Option A

4. Quick Check:

   Proper memo init and passing + base cases = correct [OK]

Hint: Initialize memo inside and pass it in recursion [OK]

Common Mistakes:

• Using global variables causing side effects
• Using mutable default arguments directly
• Ignoring base cases causing infinite recursion