Rod Cutting Problem in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the maximum revenue array with zeros.

DSA Typescript

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

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

A1

Bnull

C0

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing with 1 instead of 0 causes incorrect revenue calculations.

Using null or -1 can cause runtime errors when adding revenues.

We initialize the maxRevenue array with zeros because initially, the maximum revenue for all lengths is zero.

2fill in blank

medium

Complete the code to loop through all possible first cut lengths.

DSA Typescript

for (let i = 1; i <= [1]; i++) {

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

An

Blength

Cprice.length

DmaxRevenue.length

Attempts:

3 left

💡 Hint

Common Mistakes

Using price.length causes incorrect loop bounds.

Using maxRevenue.length is off by one due to array size.

We loop from 1 to n because n is the total length of the rod, and we consider all possible first cuts.

3fill in blank

hard

Fix the error in updating the maximum revenue inside the nested loop.

DSA Typescript

maxRevenue[j] = Math.max(maxRevenue[j], price[i - 1] + [1]);

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

AmaxRevenue[j - i]

BmaxRevenue[i]

Cprice[j - i]

Dprice[j]

Attempts:

3 left

💡 Hint

Common Mistakes

Adding price[j - i] instead of maxRevenue[j - i] causes wrong revenue calculation.

Using maxRevenue[i] ignores the remaining length.

We add the price of the first cut (price[i - 1]) to the maximum revenue of the remaining length (maxRevenue[j - i]).

4fill in blank

hard

Fill both blanks to complete the nested loop for calculating max revenue.

DSA Typescript

for (let j = [1]; j <= n; j++) {
  maxRevenue[j] = Math.max(maxRevenue[j], price[i - 1] + [2]);
}

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

Ai

Bj

Cj - i

Dn

Attempts:

3 left

💡 Hint

Common Mistakes

Starting j from 1 instead of i causes invalid cuts.

Adding maxRevenue[j] instead of maxRevenue[j - i] causes wrong results.

The inner loop starts from i because we cannot cut a piece longer than j. We add price[i - 1] to maxRevenue[j - i] for the remaining length.

5fill in blank

hard

Fill all three blanks to complete the rod cutting function.

DSA Typescript

function rodCutting(price: number[], n: number): number {
  const maxRevenue: number[] = new Array(n + 1).fill([1]);
  for (let i = 1; i <= [2]; i++) {
    for (let j = i; j <= n; j++) {
      maxRevenue[j] = Math.max(maxRevenue[j], price[i - 1] + [3]);
    }
  }
  return maxRevenue[n];
}

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

A0

Bn

CmaxRevenue[j - i]

Dprice.length

Attempts:

3 left

💡 Hint

Common Mistakes

Incorrect initialization of maxRevenue.

Wrong loop bounds for i.

Adding price[j] instead of maxRevenue[j - i].

Initialize maxRevenue with 0, loop i from 1 to n, and update maxRevenue[j] by adding price[i - 1] to maxRevenue[j - i].

Practice

1. What is the main goal of the Rod Cutting Problem in algorithms?

easy

A. To count the total number of ways to cut the rod

B. To minimize the number of cuts made on the rod

C. To maximize the total profit by cutting the rod into pieces

D. To find the shortest rod length possible

Solution

1. Step 1: Understand the problem objective

   The rod cutting problem aims to cut a rod into pieces to get the maximum total price from selling those pieces.

2. Step 2: Identify the goal

   The goal is to maximize profit, not minimize cuts or count ways.

3. Final Answer:

   To maximize the total profit by cutting the rod into pieces -> Option C

4. Quick Check:

   Maximize profit = maximize total price [OK]

Hint: Focus on maximizing profit from pieces, not cuts or counts [OK]

Common Mistakes:

• Thinking the goal is to minimize cuts
• Confusing with counting ways to cut
• Assuming shortest rod length is the goal

2. Which of the following TypeScript function signatures correctly represents the rod cutting problem function?

easy

A. function rodCutting(prices: string[], length: number): number

B. function rodCutting(length: number, prices: number[]): void

C. function rodCutting(prices: number[], length: number): string

D. function rodCutting(prices: number[], length: number): number

Solution

1. Step 1: Analyze function parameters and return type

   The function should take an array of prices (number[]) and the rod length (number), returning the maximum profit (number).

2. Step 2: Match correct signature

   function rodCutting(prices: number[], length: number): number matches this: prices array first, length second, returns number.

3. Final Answer:

   function rodCutting(prices: number[], length: number): number -> Option D

4. Quick Check:

   Input: prices array, length; Output: number [OK]

Hint: Function returns max profit as number, inputs are prices array and length [OK]

Common Mistakes:

• Swapping parameter order
• Returning void or string instead of number
• Using wrong parameter types like string[] for prices

3. What is the output of the following TypeScript code for rod cutting?

const prices = [1, 5, 8, 9];
const length = 4;
function rodCutting(prices: number[], n: number): number {
  if (n === 0) return 0;
  let maxVal = -Infinity;
  for (let i = 1; i <= n; i++) {
    maxVal = Math.max(maxVal, prices[i - 1] + rodCutting(prices, n - i));
  }
  return maxVal;
}
console.log(rodCutting(prices, length));

medium

A. 10

B. 9

C. 11

D. 8

Solution

1. Step 1: Understand recursive calls and prices

   Prices for lengths 1 to 4 are [1,5,8,9]. The function tries all cuts and sums prices recursively.

2. Step 2: Calculate max profit for length 4

   Possible cuts:
   - 1 + rodCutting(3) = 1 + 8 = 9
   - 5 + rodCutting(2) = 5 + 5 = 10
   - 8 + rodCutting(1) = 8 + 1 = 9
   - 9 + rodCutting(0) = 9 + 0 = 9
   rodCutting(2) = max(1+rodCutting(1),5+rodCutting(0)) = max(1+1,5+0)=5
   rodCutting(3) = max(1+rodCutting(2),5+rodCutting(1),8+rodCutting(0)) = max(1+5,5+1,8+0)= max(6,6,8)=8
   So max is 10.

3. Final Answer:

   10 -> Option A

4. Quick Check:

   Max profit for length 4 = 10 [OK]

Hint: Try all cuts recursively, pick max sum [OK]

Common Mistakes:

• Ignoring recursive calls
• Using wrong indices for prices
• Assuming max is price of full length only

4. Identify the bug in this TypeScript rod cutting function:

function rodCutting(prices: number[], n: number): number {
  if (n <= 0) return 0;
  let maxVal = 0;
  for (let i = 1; i < n; i++) {
    maxVal = Math.max(maxVal, prices[i - 1] + rodCutting(prices, n - i));
  }
  return maxVal;
}

medium

A. Loop should run until i <= n, not i < n

B. Base case should return -Infinity instead of 0

C. prices array indexing is off by one

D. Function should return void, not number

Solution

1. Step 1: Check loop range correctness

   The loop runs from i = 1 to i < n, so it misses the case when i = n (full length cut).

2. Step 2: Fix loop to include full length cut

   Changing loop condition to i <= n ensures all cuts including full length are considered.

3. Final Answer:

   Loop should run until i <= n, not i < n -> Option A

4. Quick Check:

   Include full length cut by i <= n [OK]

Hint: Loop must include full length cut (i <= n) [OK]

Common Mistakes:

• Using i < n misses full rod cut
• Changing base case incorrectly
• Misindexing prices array

5. Given a rod of length 5 and prices array [2, 5, 7, 8, 10], what is the maximum profit using dynamic programming approach?

hard

A. 13

B. 12

C. 14

D. 15

Solution

1. Step 1: Use bottom-up DP to find max profit

   Prices: length 1=2, 2=5, 3=7, 4=8, 5=10.
   Calculate max profit for each length:
   dp[0]=0
   dp[1]=max(2)=2
   dp[2]=max(2+dp[1],5)=max(2+2,5)=5
   dp[3]=max(2+dp[2],5+dp[1],7)=max(2+5,5+2,7)=7
   dp[4]=max(2+dp[3],5+dp[2],7+dp[1],8)=max(2+7,5+5,7+2,8)=max(9,10,9,8)=10
   dp[5]=max(2+dp[4],5+dp[3],7+dp[2],8+dp[1],10)=max(2+10,5+7,7+5,8+2,10)=max(12,12,12,10,10)=12
   Therefore, correct answer is 12.

2. Final Answer:

   12 -> Option B

3. Quick Check:

   DP max profit for length 5 = 12 [OK]

Hint: Use bottom-up DP, check all cuts for max profit [OK]

Common Mistakes:

• Ignoring smaller cuts combinations
• Miscomputing dp array values
• Assuming price of full length is max