Why Backtracking and What Greedy Cannot Solve in DSA Typescript - Test Your Knowledge

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start backtracking by choosing the first option.

DSA Typescript

function backtrack(options: number[], index: number): boolean {
  if (index === options.length) return true;
  // Choose option
  const choice = options[1];
  return backtrack(options, index + 1);
}

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

A[index]

B(index)

C{index}

D<index>

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses or curly braces instead of square brackets to access array elements.

We use square brackets [index] to access the element at position index in the array.

2fill in blank

medium

Complete the code to check if the current choice is valid before continuing backtracking.

DSA Typescript

function backtrack(options: number[], index: number): boolean {
  if (index === options.length) return true;
  const choice = options[index];
  if ([1]) {
    return backtrack(options, index + 1);
  }
  return false;
}

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

Achoice === index

Bchoice > 0

CisValid(choice)

Dchoice != null

Attempts:

3 left

💡 Hint

Common Mistakes

Using a simple comparison instead of a validation function.

Not checking validity before recursing.

We call a function isValid(choice) to check if the current choice can be part of the solution.

3fill in blank

hard

Fix the error in the backtracking function to correctly undo the choice after recursion.

DSA Typescript

function backtrack(options: number[], index: number, path: number[]): boolean {
  if (index === options.length) return true;
  const choice = options[index];
  if (isValid(choice)) {
    path.push(choice);
    if (backtrack(options, index + 1, path)) return true;
    [1];
  }
  return false;
}

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

Apath.splice(0, 1)

Bpath.push(choice)

Cpath.shift()

Dpath.pop()

Attempts:

3 left

💡 Hint

Common Mistakes

Using push instead of pop to undo choice.

Removing the wrong element from the path.

We remove the last choice from path using pop() to undo the choice before trying another.

4fill in blank

hard

Fill both blanks to implement a greedy approach that picks the best immediate option.

DSA Typescript

function greedySelect(options: number[]): number[] {
  const result: number[] = [];
  for (let i = 0; i < options.length; i++) {
    if (options[i] [1] 0) {
      result.[2](options[i]);
    }
  }
  return result;
}

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

A>

Bpush

C<

Dpop

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop instead of push to add elements.

Using wrong comparison operator.

We pick options greater than 0 and add them to result using push().

5fill in blank

hard

Fill all three blanks to implement backtracking that tries all options and backtracks properly.

DSA Typescript

function backtrackAll(options: number[], index: number, path: number[]): boolean {
  if (index === options.length) return true;
  for (let i = 0; i < options.length; i++) {
    if (isValid(options[i])) {
      path.[1](options[i]);
      if (backtrackAll(options, index + 1, path)) return true;
      path.[2]();
    }
  }
  return false;
}

const result = backtrackAll([3], 0, []);

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

Apush

Bpop

Coptions

Dpath

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to backtrack by popping from path.

Passing wrong variable as options.

We add choices with push(), remove them with pop(), and start with the options array.

Practice

1. Why is backtracking preferred over greedy algorithms for solving problems like the N-Queens puzzle?

easy

A. Because greedy algorithms always find the optimal solution faster

B. Because backtracking explores all possible solutions and can undo choices, while greedy makes irreversible choices

C. Because backtracking uses less memory than greedy algorithms

D. Because greedy algorithms are only used for sorting problems

Solution

1. Step 1: Understand backtracking's approach

   Backtracking tries all possible options and can go back (undo) if a choice leads to failure.

2. Step 2: Compare with greedy approach

   Greedy algorithms make the best immediate choice but cannot undo it, so they may miss the correct solution.

3. Final Answer:

   Because backtracking explores all possible solutions and can undo choices, while greedy makes irreversible choices -> Option B

4. Quick Check:

   Backtracking = explores all + undo [OK]

Hint: Backtracking tries all paths; greedy picks one path only [OK]

Common Mistakes:

• Thinking greedy always finds the best solution
• Confusing backtracking with brute force
• Believing backtracking uses less memory

2. Which of the following TypeScript code snippets correctly represents the start of a backtracking function signature?

easy

A. function backtrack(path number[], options number[]): void

B. function backtrack(path: number[], options: number[]) => void

C. function backtrack(path: number[], options: number[]): void

D. function backtrack(path: number[], options: number[]): number

Solution

1. Step 1: Check TypeScript function syntax

   Correct syntax uses colon ':' to specify types and parentheses for parameters.

2. Step 2: Verify return type and arrow usage

   function backtrack(path: number[], options: number[]): void uses correct syntax with void return type; others have syntax errors or wrong return type.

3. Final Answer:

   function backtrack(path: number[], options: number[]): void -> Option C

4. Quick Check:

   Correct TypeScript function syntax = function backtrack(path: number[], options: number[]): void [OK]

Hint: Look for colons and parentheses in function parameters [OK]

Common Mistakes:

• Missing colons between parameter and type
• Using arrow '=>' incorrectly in function signature
• Wrong return type specified

3. Consider this TypeScript backtracking code snippet for generating subsets:

function backtrack(start: number, path: number[], nums: number[], result: number[][]) {
  result.push([...path]);
  for (let i = start; i < nums.length; i++) {
    path.push(nums[i]);
    backtrack(i + 1, path, nums, result);
    path.pop();
  }
}

const nums = [1, 2];
const result: number[][] = [];
backtrack(0, [], nums, result);
console.log(result);

What is the output printed?

medium

A. [[], [2], [1, 2], [1]]

B. [[1], [2]]

C. [[1, 2]]

D. [[], [1], [1, 2], [2]]

Solution

1. Step 1: Trace backtracking calls with nums = [1, 2]

   Start with empty path [], add it to result. Then add 1, recurse, add [1], add 2, recurse, add [1,2], backtrack, add 2 alone, add [2].

2. Step 2: Collect all subsets generated

   Subsets are [], [1], [1, 2], and [2] in order.

3. Final Answer:

   [[], [1], [1, 2], [2]] -> Option D

4. Quick Check:

   All subsets generated = [[], [1], [1, 2], [2]] [OK]

Hint: Backtracking with push/pop generates all subsets including empty [OK]

Common Mistakes:

• Forgetting to add empty subset
• Not popping after recursion causing wrong subsets
• Mixing order of subsets

4. The following TypeScript backtracking code tries to find all permutations of [1, 2], but it has a bug:

function permute(nums: number[], path: number[], used: boolean[], result: number[][]) {
  if (path.length === nums.length) {
    result.push(path);
    return;
  }
  for (let i = 0; i < nums.length; i++) {
    if (used[i]) continue;
    path.push(nums[i]);
    used[i] = true;
    permute(nums, path, used, result);
    path.pop();
    used[i] = false;
  }
}

const result: number[][] = [];
permute([1, 2], [], [false, false], result);
console.log(result);

What is the bug and how to fix it?

medium

A. Bug: Pushing path directly causes reference issues; fix by pushing a copy of path

B. Bug: used array is not updated correctly; fix by removing used[i] = false

C. Bug: Base case condition is wrong; fix by changing path.length === nums.length to path.length > nums.length

D. Bug: Loop should start from 1 instead of 0; fix by changing for loop start

Solution

1. Step 1: Identify the problem with pushing path

   Pushing path directly adds the same array reference multiple times, causing all entries to be the same final path.

2. Step 2: Fix by pushing a copy of path

   Use result.push([...path]) to push a new array copy each time.

3. Final Answer:

   Bug: Pushing path directly causes reference issues; fix by pushing a copy of path -> Option A

4. Quick Check:

   Push copy of path, not reference [OK]

Hint: Always push a copy of path in backtracking results [OK]

Common Mistakes:

• Pushing path reference instead of copy
• Incorrect base case condition
• Misusing used array updates

5. You want to solve the classic "Subset Sum" problem: given an array of positive integers and a target sum, find if any subset sums exactly to the target. Why can't a greedy algorithm solve this correctly in all cases, and how does backtracking help?

hard

A. Greedy fails because picking largest numbers first may miss exact sum; backtracking tries all subsets to find exact match

B. Greedy fails because it sorts the array; backtracking sorts and tries subsets

C. Greedy fails because it uses recursion; backtracking uses iteration

D. Greedy fails because it only works on sorted arrays; backtracking only works on unsorted arrays

Solution

1. Step 1: Understand greedy approach limitation

   Greedy picks the largest numbers first, which may overshoot or miss the exact target sum.

2. Step 2: How backtracking solves the problem

   Backtracking tries all subsets by including or excluding each number, ensuring it finds an exact sum if it exists.

3. Final Answer:

   Greedy fails because picking largest numbers first may miss exact sum; backtracking tries all subsets to find exact match -> Option A

4. Quick Check:

   Subset sum needs all subsets tried = Greedy fails because picking largest numbers first may miss exact sum; backtracking tries all subsets to find exact match [OK]

Hint: Subset sum needs all subsets; greedy picks only some [OK]

Common Mistakes:

• Thinking greedy always finds exact sum
• Confusing sorting with solving approach
• Believing backtracking is iterative only