Fibonacci Using DP in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Fibonacci DP with Memoization

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

DSA Typescript

function fib(n: number, memo: number[] = []): number {
  if (n <= 1) return n;
  if (memo[n] !== undefined) return memo[n];
  memo[n] = fib(n - 1, memo) + fib(n - 2, memo);
  return memo[n];
}
console.log(fib(7));

A 13

B 34

C 8

D 21

💡 Hint

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

fib(0)=0, fib(1)=1, fib(2)=1, fib(3)=2, fib(4)=3, fib(5)=5, fib(6)=8, fib(7)=13. The code returns fib(7) = fib(6) + fib(5) = 8 + 5 = 13.

❓ Predict Output

intermediate

Output of Fibonacci DP with Tabulation

What is the output of this TypeScript code that calculates Fibonacci numbers using tabulation (bottom-up approach)?

DSA Typescript

function fib(n: number): number {
  const dp: number[] = [0, 1];
  for (let i = 2; i <= n; i++) {
    dp[i] = dp[i - 1] + dp[i - 2];
  }
  return dp[n];
}
console.log(fib(5));

A 8

B 3

C 5

D 13

💡 Hint

The Fibonacci sequence starts 0, 1, 1, 2, 3, 5, 8...

fib(5) is the 5th Fibonacci number starting from 0 index: 0,1,1,2,3,5 so fib(5) = 5.

🧠 Conceptual

advanced

Why use Dynamic Programming for Fibonacci?

Why is dynamic programming a better approach than simple recursion for calculating Fibonacci numbers?

A It avoids repeated calculations by storing intermediate results.

B It uses less memory by not storing any results.

C It calculates Fibonacci numbers using random guesses.

D It only works for small Fibonacci numbers.

💡 Hint

Think about how recursion repeats work for the same inputs.

Dynamic programming stores results of subproblems to avoid recalculating them, making the process efficient.

🔧 Debug

advanced

Identify the error in Fibonacci DP code

What error will this TypeScript code produce when calculating Fibonacci numbers using memoization?

DSA Typescript

function fib(n: number, memo: number[] = []): number {
  if (n <= 1) return n;
  if (memo[n] !== undefined) return memo[n];
  memo[n] = fib(n - 1, memo) + fib(n - 2, memo);
  return memo[n];
}
console.log(fib(0));

A Returns undefined

B Returns 0 correctly

C Stack overflow error

D Returns 1 incorrectly

💡 Hint

Check how memo[n] is checked before returning.

The code returns 0 correctly for fib(0) because the base case `if (n <= 1)` is checked before the memo check. However, the memo check `if (memo[n])` uses truthiness, which treats 0 as falsy and would fail if 0 were memoized. Base cases also aren't stored in memo.

🚀 Application

expert

Calculate large Fibonacci number efficiently

Which approach is best to calculate the 50th Fibonacci number efficiently in TypeScript?

A Using a for loop with repeated addition without storing previous results

B Recursion with memoization (top-down DP)

C Simple recursion without memoization

D Iterative tabulation (bottom-up DP)

💡 Hint

Consider time and space efficiency for large inputs.

Iterative tabulation uses a simple loop and stores only needed values, making it faster and more memory efficient than recursion with memoization for large n.

Practice

1. What is the main advantage of using Dynamic Programming (DP) to calculate Fibonacci numbers compared to a simple recursive approach?

easy

A. It uses less memory by not storing any results.

B. It avoids repeated calculations by storing intermediate results.

C. It calculates Fibonacci numbers randomly.

D. It only works for small Fibonacci numbers.

Solution

1. Step 1: Understand recursive Fibonacci calculation

   Simple recursion recalculates the same Fibonacci numbers many times, causing inefficiency.

2. Step 2: Understand DP optimization

   DP stores previously calculated Fibonacci numbers in a table (memoization or tabulation) to avoid repeated work.

3. Final Answer:

   It avoids repeated calculations by storing intermediate results. -> Option B

4. Quick Check:

   DP = stores results to save time [OK]

Hint: DP saves time by remembering past answers [OK]

Common Mistakes:

• Thinking DP uses less memory than recursion
• Believing DP calculates randomly
• Assuming DP only works for small inputs

2. Which of the following TypeScript code snippets correctly initializes the DP array for Fibonacci calculation up to n?

easy

A. const dp: number[] = new Array(n + 1).fill(0); dp[1] = 1;

B. const dp: number[] = new Array(n).fill(1);

C. const dp: number[] = []; dp[0] = 1; dp[1] = 1;

D. const dp: number[] = new Array(n + 1); dp[1] = 1;

Solution

1. Step 1: Check array size and initialization

   We need an array of size n+1 to store Fibonacci numbers from 0 to n. Filling with 0 and setting dp[1] = 1 is correct.

2. Step 2: Validate each option

   const dp: number[] = new Array(n + 1).fill(0); dp[1] = 1; correctly creates dp with size n+1, fills with 0, and sets dp[1] = 1. Others have wrong sizes or initial values.

3. Final Answer:

   const dp: number[] = new Array(n + 1).fill(0); dp[1] = 1; -> Option A

4. Quick Check:

   Array size = n+1, dp[1] = 1 [OK]

Hint: DP array size must be n+1 with dp[1] = 1 [OK]

Common Mistakes:

• Using array size n instead of n+1
• Initializing dp[0] or dp[1] incorrectly
• Leaving dp array uninitialized

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

function fib(n: number): number {
  const dp: number[] = new Array(n + 1).fill(0);
  dp[1] = 1;
  for (let i = 2; i <= n; i++) {
    dp[i] = dp[i - 1] + dp[i - 2];
  }
  return dp[n];
}
console.log(fib(5));

medium

A. 13

B. 8

C. 3

D. 5

Solution

1. Step 1: Trace DP array values for n=5

   dp[0]=0, dp[1]=1; then dp[2]=1, dp[3]=2, dp[4]=3, dp[5]=5.

2. Step 2: Return dp[5]

   The function returns dp[5] which is 5.

3. Final Answer:

   5 -> Option D

4. Quick Check:

   Fibonacci(5) = 5 [OK]

Hint: Remember Fibonacci sequence: 0,1,1,2,3,5... [OK]

Common Mistakes:

• Confusing index starting point
• Returning dp[n-1] instead of dp[n]
• Miscomputing dp values in loop

4. Identify the error in this TypeScript DP Fibonacci code and select the fix:

function fib(n: number): number {
  const dp: number[] = new Array(n).fill(0);
  dp[0] = 0;
  dp[1] = 1;
  for (let i = 2; i <= n; i++) {
    dp[i] = dp[i - 1] + dp[i - 2];
  }
  return dp[n];
}

medium

A. Change array size to n+1.

B. Initialize dp[2] to 1 before the loop.

C. Start loop from i = 1 instead of 2.

D. Remove dp[0] initialization.

Solution

1. Step 1: Analyze array size and access

   Array dp has size n, but loop accesses dp[n] beyond the initial length.

2. Step 2: Fix array size

   Increase dp size to n+1 to safely access dp[n].

3. Final Answer:

   Change array size to n+1 to avoid out-of-bounds error. -> Option A

4. Quick Check:

   Array size must cover dp[n] [OK]

Hint: Array size must be n+1 for dp[n] access [OK]

Common Mistakes:

• Ignoring array size mismatch
• Starting loop incorrectly
• Unnecessary dp initialization changes

5. You want to optimize the space used by the DP Fibonacci function. Which modification correctly reduces space complexity from O(n) to O(1)?

hard

A. Use a recursive function without memoization.

B. Store all Fibonacci numbers in a global array.

C. Use two variables to store only the last two Fibonacci numbers instead of an array.

D. Initialize the dp array with zeros and fill it completely every call.

Solution

1. Step 1: Understand space usage in DP Fibonacci

   DP uses an array of size n+1, so space is O(n).

2. Step 2: Optimize space by storing only needed values

   Since each Fibonacci number depends only on the previous two, storing just two variables suffices.

3. Step 3: Compare options

   Use two variables to store only the last two Fibonacci numbers instead of an array. uses two variables, reducing space to O(1). Others do not reduce space or are inefficient.

4. Final Answer:

   Use two variables to store only the last two Fibonacci numbers instead of an array. -> Option C

5. Quick Check:

   Two vars = O(1) space [OK]

Hint: Keep only last two Fibonacci numbers to save space [OK]

Common Mistakes:

• Using recursion without memoization increases time
• Storing all numbers globally wastes space
• Filling full dp array every call wastes memory