Memoization Top Down DP in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Fibonacci with Memoization

What is the output of the following JavaScript code that calculates Fibonacci numbers using memoization?

DSA Javascript

function fib(n, memo = {}) {
  if (n <= 1) return n;
  if (memo[n]) return memo[n];
  memo[n] = fib(n - 1, memo) + fib(n - 2, memo);
  return memo[n];
}
console.log(fib(6));

A 13

B 8

C 5

D 21

💡 Hint

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

The function calculates fib(6) which is the 6th Fibonacci number starting from 0. The sequence is 0,1,1,2,3,5,8... so fib(6) = 8.

❓ Predict Output

intermediate

Memoization Cache Content After Execution

After running the following code, what is the content of the memo object?

DSA Javascript

function climbStairs(n, memo = {}) {
  if (n <= 2) return n;
  if (memo[n]) return memo[n];
  memo[n] = climbStairs(n - 1, memo) + climbStairs(n - 2, memo);
  return memo[n];
}
climbStairs(4);

A {"3":3,"4":5}

B {"1":1,"2":2,"3":3,"4":5}

C {"2":2,"3":3,"4":5}

D {"4":5}

💡 Hint

Check which values are stored during recursive calls for n=4.

The memo stores results for n=3 and n=4 only because base cases (n=1,2) return directly without memo storage.

🔧 Debug

advanced

Identify the Error in Memoized Factorial

What error will the following code produce when calling factorial(5)?

DSA Javascript

function factorial(n, memo = {}) {
  if (n === 0) return 1;
  if (memo[n]) return memo[n];
  memo[n] = n * factorial(n - 1, memo);
  return memo[n];
}
factorial(5);

A Maximum call stack size exceeded

B TypeError: memo is not a function

C ReferenceError: memo is not defined

D No error, returns 120

💡 Hint

Check the recursive call parameters carefully.

There is no error. The recursive call misses passing memo, but default parameter provides {}, so it computes correctly without shared memoization, returning 120.

🚀 Application

advanced

Number of Ways to Make Change with Memoization

What is the output of the following code that calculates the number of ways to make change for amount 5 using coins [1,2,5] with memoization?

DSA Javascript

function change(amount, coins, index = 0, memo = {}) {
  const key = amount + '-' + index;
  if (amount === 0) return 1;
  if (amount < 0 || index === coins.length) return 0;
  if (memo[key]) return memo[key];
  memo[key] = change(amount - coins[index], coins, index, memo) + change(amount, coins, index + 1, memo);
  return memo[key];
}
console.log(change(5, [1,2,5]));

A 3

B 5

C 4

D 6

💡 Hint

Count all combinations of coins that sum to 5.

There are 4 ways: {1x5}, {2x2 + 1x1}, {1x2 + 3x1}, {5x1}.

🧠 Conceptual

expert

Memoization Cache Size in Top-Down DP

In a top-down memoized solution for the Fibonacci sequence, what is the maximum number of unique entries stored in the memo object when calculating fib(n)?

A n + 1

B 2n

C n - 1

D n * n

💡 Hint

Consider how many different arguments are passed to the recursive function.

The memo stores results for all integers from 0 up to n, so total entries are n+1.

Practice

1. What is the main purpose of memoization in top-down dynamic programming?

easy

A. To store results of subproblems to avoid repeated calculations

B. To sort the input data before processing

C. To convert recursive code into iterative code

D. To reduce the memory usage by deleting variables

Solution

1. Step 1: Understand memoization concept

   Memoization saves the results of expensive function calls and returns the cached result when the same inputs occur again.

2. Step 2: Identify its role in top-down DP

   In top-down dynamic programming, memoization prevents repeated calculations of the same subproblems by storing their results.

3. Final Answer:

   To store results of subproblems to avoid repeated calculations -> Option A

4. Quick Check:

   Memoization = Store subproblem results [OK]

Hint: Memoization caches answers to reuse later [OK]

Common Mistakes:

• Confusing memoization with sorting
• Thinking memoization reduces memory usage
• Believing memoization converts recursion to iteration

2. Which of the following is the correct way to declare a memo object in JavaScript for top-down DP?

easy

A. const memo = 0;

B. let memo = [];

C. const memo = new Map();

D. var memo = function() {};

Solution

1. Step 1: Identify memo storage type

   Memoization requires a data structure to store key-value pairs of subproblem results. Map is ideal for this in JavaScript.

2. Step 2: Check options for correct syntax

   const memo = new Map(); uses new Map() which is correct. let memo = []; is an array, which can work but less flexible. var memo = function() {}; is a function, incorrect. const memo = 0; is a number, incorrect.

3. Final Answer:

   const memo = new Map(); -> Option C

4. Quick Check:

   Memo object = Map() [OK]

Hint: Use Map() for flexible memo keys [OK]

Common Mistakes:

• Using a function instead of an object
• Initializing memo as a number
• Confusing array with Map for memo

3. What will be the output of the following JavaScript code using memoization for Fibonacci?

const memo = new Map();
function fib(n) {
  if (n <= 1) return n;
  if (memo.has(n)) return memo.get(n);
  const result = fib(n - 1) + fib(n - 2);
  memo.set(n, result);
  return result;
}
console.log(fib(5));

medium

A. 5

B. 8

C. 3

D. 13

Solution

1. Step 1: Understand Fibonacci sequence

   Fibonacci sequence starts as 0,1,1,2,3,5,8,... So fib(5) = 5.

2. Step 2: Trace the code execution

   The function uses memoization to avoid repeated calls. fib(5) calculates fib(4)+fib(3), and so on, finally returning 5.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   fib(5) = 5 [OK]

Hint: Recall Fibonacci sequence values [OK]

Common Mistakes:

• Confusing fib(5) with fib(6)
• Ignoring base cases
• Not understanding memo usage

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

const memo = {};
function factorial(n) {
  if (n === 0) return 1;
  if (memo[n]) return memo[n];
  memo[n] = n * factorial(n - 1);
  return memo[n];
}
console.log(factorial(5));

medium

A. Change base case to 'if (n === 1) return 1;'

B. Change 'if (memo[n])' to 'if (memo.hasOwnProperty(n))'

C. Initialize memo as 'const memo = new Map();'

D. Remove memo and use plain recursion

Solution

1. Step 1: Understand the bug in memo check

   Using 'if (memo[n])' fails when memo[n] is 0 or falsy. It should check if the key exists.

2. Step 2: Fix by checking key existence

   Using 'memo.hasOwnProperty(n)' correctly checks if the result is stored, avoiding false negatives.

3. Final Answer:

   Change 'if (memo[n])' to 'if (memo.hasOwnProperty(n))' -> Option B

4. Quick Check:

   Check key existence, not truthiness [OK]

Hint: Check key presence, not value truthiness [OK]

Common Mistakes:

• Checking memo[n] directly causes bugs for 0 or falsy values
• Changing base case unnecessarily
• Removing memo defeats purpose

5. Given the following top-down memoized function to count ways to climb stairs, what is the output of countWays(4)?

const memo = {};
function countWays(n) {
  if (n === 0) return 1;
  if (n < 0) return 0;
  if (memo.hasOwnProperty(n)) return memo[n];
  memo[n] = countWays(n - 1) + countWays(n - 2);
  return memo[n];
}
console.log(countWays(4));

hard

A. 7

B. 6

C. 8

D. 5

Solution

1. Step 1: Understand the problem

   This function counts ways to climb stairs taking 1 or 2 steps. Base cases: countWays(0)=1, countWays(negative)=0.

2. Step 2: Calculate countWays(4) step-by-step

   countWays(4) = countWays(3) + countWays(2) countWays(3) = countWays(2) + countWays(1) countWays(2) = countWays(1) + countWays(0) countWays(1) = countWays(0) + countWays(-1) countWays(0) = 1, countWays(-1) = 0 So countWays(1) = 1 + 0 = 1 countWays(2) = 1 + 1 = 2 countWays(3) = 2 + 1 = 3 countWays(4) = 3 + 2 = 5

3. Final Answer:

   5 -> Option D

4. Quick Check:

   Ways to climb 4 stairs = 5 [OK]

Hint: Count ways as sum of previous two counts [OK]

Common Mistakes:

• Miscounting base cases
• Forgetting negative input returns 0
• Mixing up addition order