Memoization to Optimize Recursion in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Fibonacci with Memoization

What is the output of the following code that uses memoization to compute Fibonacci numbers?

DSA Python

def fib(n, 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(6))

A 13

B 8

C 21

D 5

💡 Hint

Remember Fibonacci sequence starts 0,1,1,2,3,5,8,13...

The Fibonacci sequence for n=6 is 8. The function uses memoization to avoid repeated calculations.

❓ Predict Output

intermediate

Output of Factorial with Memoization

What is the output of this factorial function using memoization?

DSA Python

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

print(factorial(5))

A 24

B 720

C 60

D 120

💡 Hint

Factorial of 5 is 5*4*3*2*1.

The factorial of 5 is 120. Memoization stores intermediate results to speed up recursion.

🔧 Debug

advanced

Identify the error in memoized Fibonacci

What error does this code raise when called with fib(4)?

DSA Python

def fib(n, memo={}):
    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]

print(fib(4))

A KeyError

B RecursionError

C No error, output is 3

D TypeError

💡 Hint

Check the order of base case and memo check.

The code runs correctly and outputs 3 for fib(4). The base case is checked before memo lookup, so no error occurs.

❓ Predict Output

advanced

Output of Counting Paths with Memoization

What is the output of this code that counts paths in a grid using memoization?

DSA Python

def count_paths(m, n, memo={}):
    if m == 1 or n == 1:
        return 1
    if (m, n) in memo:
        return memo[(m, n)]
    memo[(m, n)] = count_paths(m-1, n, memo) + count_paths(m, n-1, memo)
    return memo[(m, n)]

print(count_paths(3, 3))

A 6

B 9

C 12

D 10

💡 Hint

Number of paths in a 3x3 grid is a known combinatorial value.

The number of paths from top-left to bottom-right in a 3x3 grid moving only right or down is 4 choose 2 = 6, the function returns 6 paths for 2x2 steps. Here m=3,n=3 means 2 steps right and 2 steps down, total 4 steps, combinations 6. So output is 6.

❓ Predict Output

expert

Output of Memoized Edit Distance Calculation

What is the output of this memoized recursive function calculating edit distance between 'kitten' and 'sitting'?

DSA Python

def edit_distance(s1, s2, i=0, j=0, memo={}):
    if (i, j) in memo:
        return memo[(i, j)]
    if i == len(s1):
        return len(s2) - j
    if j == len(s2):
        return len(s1) - i
    if s1[i] == s2[j]:
        memo[(i, j)] = edit_distance(s1, s2, i+1, j+1, memo)
    else:
        insert = 1 + edit_distance(s1, s2, i, j+1, memo)
        delete = 1 + edit_distance(s1, s2, i+1, j, memo)
        replace = 1 + edit_distance(s1, s2, i+1, j+1, memo)
        memo[(i, j)] = min(insert, delete, replace)
    return memo[(i, j)]

print(edit_distance('kitten', 'sitting'))

A 3

B 4

C 5

D 6

💡 Hint

Edit distance counts minimum edits to convert one string to another.

The edit distance between 'kitten' and 'sitting' is 3 (replace k->s, replace e->i, insert g). The memoization avoids repeated calculations.

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