Greedy vs DP How to Know Which to Apply in DSA Typescript - Interactive Comparison Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if a problem has the greedy-choice property.

DSA Typescript

function hasGreedyChoiceProperty(problem: any): boolean {
  // If local optimal choices lead to global optimum
  return problem.[1];
}

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

ArequiresMemoization

BalwaysChooseFirst

ChasOverlappingSubproblems

DlocalOptimumLeadsToGlobal

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing greedy-choice property with overlapping subproblems.

Assuming all problems have greedy-choice property.

The greedy-choice property means that making a local optimal choice at each step leads to a global optimum.

2fill in blank

medium

Complete the code to check if a problem has overlapping subproblems.

DSA Typescript

function hasOverlappingSubproblems(problem: any): boolean {
  // If subproblems repeat
  return problem.[1];
}

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

AlocalOptimumLeadsToGlobal

BalwaysChooseFirst

ChasOverlappingSubproblems

DrequiresSorting

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up overlapping subproblems with greedy-choice property.

Assuming sorting is always required.

Overlapping subproblems means the problem can be broken into subproblems which are solved multiple times.

3fill in blank

hard

Fix the error in the function that decides which approach to apply.

DSA Typescript

function chooseApproach(problem: any): string {
  if (problem.[1]) {
    return 'Greedy';
  } else if (problem.hasOverlappingSubproblems) {
    return 'Dynamic Programming';
  } else {
    return 'Brute Force';
  }
}

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

AlocalOptimumLeadsToGlobal

BhasOverlappingSubproblems

CalwaysChooseFirst

DrequiresMemoization

Attempts:

3 left

💡 Hint

Common Mistakes

Checking overlapping subproblems before greedy-choice property.

Using wrong property names.

The decision should check if the problem has the greedy-choice property first to choose Greedy.

4fill in blank

hard

Fill both blanks to complete the function that explains when to use DP.

DSA Typescript

function shouldUseDP(problem: any): boolean {
  return problem.[1] && problem.[2];
}

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

AhasOverlappingSubproblems

BlocalOptimumLeadsToGlobal

CrequiresMemoization

DalwaysChooseFirst

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing greedy-choice property with DP conditions.

Missing memoization requirement.

Dynamic Programming is used when the problem has overlapping subproblems and requires memoization.

5fill in blank

hard

Fill all three blanks to complete the function that decides the algorithm type based on problem properties.

DSA Typescript

function decideAlgorithm(problem: any): string {
  if (problem.[1]) {
    return 'Greedy';
  } else if (problem.[2] && problem.[3]) {
    return 'Dynamic Programming';
  } else {
    return 'Brute Force';
  }
}

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

AlocalOptimumLeadsToGlobal

BhasOverlappingSubproblems

CrequiresMemoization

DalwaysChooseFirst

Attempts:

3 left

💡 Hint

Common Mistakes

Wrong order of checks.

Missing one of the DP conditions.

The function first checks for greedy-choice property, then overlapping subproblems and memoization for DP, else brute force.

Practice

1. Which of the following best describes when to use a greedy algorithm instead of dynamic programming?

easy

A. When the problem has the greedy choice property and optimal substructure

B. When the problem requires checking all possible combinations

C. When the problem has overlapping subproblems but no optimal substructure

D. When the problem needs to store all intermediate results

Solution

1. Step 1: Understand greedy choice property

   A greedy algorithm works when choosing the best option at each step leads to a global optimum.

2. Step 2: Check optimal substructure

   Optimal substructure means the optimal solution can be built from optimal solutions of subproblems.

3. Final Answer:

   When the problem has the greedy choice property and optimal substructure -> Option A

4. Quick Check:

   Greedy = greedy choice + optimal substructure [OK]

Hint: Use greedy if local best leads to global best [OK]

Common Mistakes:

• Confusing overlapping subproblems with greedy applicability
• Using greedy when problem needs full exploration
• Ignoring optimal substructure requirement

2. Which syntax correctly declares a memoization object in TypeScript for dynamic programming?

easy

A. var memo: number[] = [];

B. let memo = new Map();

C. const memo: Record = {};

D. const memo = {} as number[];

Solution

1. Step 1: Understand memo type for DP

   Memoization stores results with keys, so Record is suitable.

2. Step 2: Check syntax correctness

   const memo: Record = {}; correctly declares an empty object with number keys and values.

3. Final Answer:

   const memo: Record = {}; -> Option C

4. Quick Check:

   Memo object uses Record type [OK]

Hint: Use Record for memo objects [OK]

Common Mistakes:

• Using var instead of const or let
• Incorrect type assertion for memo
• Using Map without type parameters

3. Consider this TypeScript code snippet for a problem that can be solved by greedy or DP:

function maxSum(arr: number[]): number {
  let sum = 0;
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] > 0) sum += arr[i];
  }
  return sum;
}
console.log(maxSum([-1, 2, 3, -5, 4]));

What is the output?

medium

A. 9

B. 4

C. 0

D. Error

Solution

1. Step 1: Trace the loop and sum positive numbers

   Positive numbers are 2, 3, and 4. Sum = 2 + 3 + 4 = 9.

2. Step 2: Confirm return value

   The function returns sum = 9, so console.log prints 9.

3. Final Answer:

   9 -> Option A

4. Quick Check:

   Sum positives = 9 [OK]

Hint: Sum only positive numbers for max sum greedy [OK]

Common Mistakes:

• Adding negative numbers mistakenly
• Returning zero instead of sum
• Confusing output with array length

4. The following TypeScript function is intended to solve the Fibonacci sequence using DP with memoization. What is the bug?

function fib(n: number, memo: Record = {}): number {
  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(5));

medium

A. The recursive calls should be fib(n + 1) and fib(n + 2)

B. The base case should be 'if (n < 0) return 0;'

C. The function should not use default parameter for memo

D. The memo check should be 'if (memo[n] !== undefined)' to handle zero

Solution

1. Step 1: Analyze memo check condition

   Checking 'if (memo[n])' fails when memo[n] is 0, which is falsy.

2. Step 2: Correct memo check

   Use 'if (memo[n] !== undefined)' to correctly detect stored values including zero.

3. Final Answer:

   The memo check should be 'if (memo[n] !== undefined)' to handle zero -> Option D

4. Quick Check:

   Memo check must handle zero values [OK]

Hint: Check memo with !== undefined, not truthy check [OK]

Common Mistakes:

• Using truthy check for memo causing wrong cache hits
• Wrong base case for Fibonacci
• Incorrect recursive call directions

5. You have a set of tasks with durations and deadlines. You want to maximize the number of tasks completed before their deadlines. Which approach is best and why?

interface Task {
  duration: number;
  deadline: number;
}
function scheduleTasks(tasks: Task[]): number {
  // Implementation needed
}

hard

A. Use dynamic programming to try all subsets and pick max count

B. Use a greedy algorithm sorting tasks by earliest deadline to maximize count

C. Use greedy sorting by longest duration first to minimize total time

D. Use dynamic programming to minimize total duration ignoring deadlines

Solution

1. Step 1: Understand problem goal

   Maximize number of tasks completed before deadlines means scheduling tasks efficiently.

2. Step 2: Identify best approach

   Greedy algorithm sorting by earliest deadline ensures maximum tasks fit before deadlines.

3. Final Answer:

   Use a greedy algorithm sorting tasks by earliest deadline to maximize count -> Option B

4. Quick Check:

   Earliest deadline first greedy maximizes tasks [OK]

Hint: Sort tasks by earliest deadline for max count [OK]

Common Mistakes:

• Trying all subsets with DP causing inefficiency
• Sorting by longest duration wastes time
• Ignoring deadlines in scheduling