Palindrome Partitioning Using Backtracking in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if a substring is a palindrome.

DSA Javascript

function isPalindrome(s, left, right) {
  while (left < right) {
    if (s[left] !== s[right]) {
      return false;
    }
    left++;
    right[1];
  }
  return true;
}

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

A-= 1

B+= 1

C--

D++

Attempts:

3 left

💡 Hint

Common Mistakes

Using right++ instead of right-=1 causes infinite loop.

Using right+=1 moves pointer in wrong direction.

To check palindrome, we move right pointer backward by 1 each time, so right -= 1.

2fill in blank

medium

Complete the code to add a substring to the current partition.

DSA Javascript

function backtrack(start, s, currentPartition, result) {
  if (start === s.length) {
    result.push([...currentPartition]);
    return;
  }
  for (let end = start; end < s.length; end++) {
    if (isPalindrome(s, start, end)) {
      currentPartition.[1](s.substring(start, end + 1));
      backtrack(end + 1, s, currentPartition, result);
      currentPartition.pop();
    }
  }
}

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

Aappend

Badd

Cpush

Dinsert

Attempts:

3 left

💡 Hint

Common Mistakes

Using append() which is not a JavaScript array method.

Using add() which is not defined for arrays.

In JavaScript arrays, push() adds an element to the end.

3fill in blank

hard

Fix the error in the base case condition to stop recursion correctly.

DSA Javascript

function backtrack(start, s, currentPartition, result) {
  if (start [1] s.length) {
    result.push([...currentPartition]);
    return;
  }
  // rest of code
}

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

A<

B===

C>

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using start < s.length causes infinite recursion.

Using start <= s.length causes out-of-bound errors.

The base case is when start equals s.length, meaning we have partitioned the whole string.

4fill in blank

hard

Fill both blanks to complete the for loop and recursive call correctly.

DSA Javascript

for (let end = [1]; end < s.length; end++) {
  if (isPalindrome(s, start, end)) {
    currentPartition.push(s.substring(start, end + 1));
    backtrack([2], s, currentPartition, result);
    currentPartition.pop();
  }
}

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

Astart

Bend

Cend + 1

Dstart + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Starting loop from end instead of start.

Calling backtrack with end instead of end + 1.

The loop starts from start, and recursive call moves to end + 1 to continue partitioning.

5fill in blank

hard

Fill all three blanks to complete the palindrome partitioning function.

DSA Javascript

function partition(s) {
  const result = [];
  function backtrack(start, s, currentPartition, result) {
    if (start === s.length) {
      result.push([...currentPartition]);
      return;
    }
    for (let end = [1]; end < s.length; end++) {
      if (isPalindrome(s, start, end)) {
        currentPartition.push(s.substring(start, end + 1));
        backtrack([2], s, currentPartition, result);
        currentPartition.pop();
      }
    }
  }
  backtrack([3], s, [], result);
  return result;
}

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

Astart

Bend + 1

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Starting loop from 0 inside recursion causes repeated work.

Calling backtrack with wrong start index.

Starting initial call from 1 instead of 0.

Loop starts at start, recursive call moves to end + 1, and initial call starts at 0.

Practice

1. What is the main goal of palindrome partitioning using backtracking?

easy

A. To split a string into all possible palindrome substrings

B. To find the longest palindrome substring in a string

C. To reverse a string using recursion

D. To count the number of palindromes in a string

Solution

1. Step 1: Understand palindrome partitioning

   Palindrome partitioning means dividing a string into parts where each part is a palindrome.

2. Step 2: Role of backtracking

   Backtracking helps explore all possible ways to split the string and keep only palindrome parts.

3. Final Answer:

   To split a string into all possible palindrome substrings -> Option A

4. Quick Check:

   Palindrome partitioning = splitting into palindrome substrings [OK]

Hint: Backtracking tries all splits keeping palindromes only [OK]

Common Mistakes:

• Confusing palindrome partitioning with longest palindrome substring
• Thinking it only finds one palindrome partition
• Assuming it reverses the string

2. Which of the following is the correct way to check if a substring s.slice(start, end) is a palindrome in JavaScript?

easy

A. Check if s.slice(start, end) === s.slice(end, start).reverse()

B. Check if s.slice(start, end) === s.slice(start, end).split('').reverse().join('')

C. Check if s.slice(start, end) === s.reverse()

D. Check if s.slice(start, end) === s.split('').reverse()

Solution

1. Step 1: Extract substring correctly

   Use s.slice(start, end) to get substring from start to end-1.

2. Step 2: Check palindrome by reversing substring

   Reverse substring by splitting to array, reversing, then joining back to string.

3. Final Answer:

   Check if s.slice(start, end) === s.slice(start, end).split('').reverse().join('') -> Option B

4. Quick Check:

   Reverse substring and compare equals original [OK]

Hint: Reverse substring with split, reverse, join to check palindrome [OK]

Common Mistakes:

• Using slice with reversed indices (end before start)
• Trying to reverse string directly without split
• Comparing substring to reversed full string

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

function isPalindrome(s) {
  return s === s.split('').reverse().join('');
}

function backtrack(s, start, path, result) {
  if (start === s.length) {
    result.push([...path]);
    return;
  }
  for (let end = start + 1; end <= s.length; end++) {
    let sub = s.slice(start, end);
    if (isPalindrome(sub)) {
      path.push(sub);
      backtrack(s, end, path, result);
      path.pop();
    }
  }
}

let result = [];
backtrack('aab', 0, [], result);
console.log(result);

medium

A. [["a", "a", "b"], ["aa", "b"]]

B. [["aab"]]

C. [["a", "ab"]]

D. [["aa", "ab"]]

Solution

1. Step 1: Check palindrome substrings in 'aab'

   Substrings: 'a', 'aa', 'aab', 'ab', 'b'. Palindromes are 'a', 'aa', 'b'.

2. Step 2: Backtracking builds partitions

   Partitions: ['a','a','b'] and ['aa','b'] are valid palindrome partitions.

3. Final Answer:

   [["a", "a", "b"], ["aa", "b"]] -> Option A

4. Quick Check:

   All palindrome partitions of 'aab' = [['a','a','b'], ['aa','b']] [OK]

Hint: Check all palindrome splits recursively to get partitions [OK]

Common Mistakes:

• Including non-palindrome substrings like 'ab'
• Missing the partition ['aa','b']
• Confusing output format with strings instead of arrays

4. Identify the bug in this backtracking code for palindrome partitioning:

function backtrack(s, start, path, result) {
  if (start > s.length) {
    result.push(path);
    return;
  }
  for (let end = start + 1; end <= s.length; end++) {
    let sub = s.slice(start, end);
    if (sub === sub.split('').reverse().join('')) {
      path.push(sub);
      backtrack(s, end, path, result);
      path.pop();
    }
  }
}

medium

A. The path array should not be mutated with push and pop

B. The substring check is incorrect; should use a separate isPalindrome function

C. The base case condition should be start === s.length, not start > s.length

D. The for loop should start from end = start, not start + 1

Solution

1. Step 1: Analyze base case condition

   Base case triggers when start > s.length, but valid partitions end exactly at start === s.length.

2. Step 2: Correct base case to push result

   Change condition to start === s.length to add current path to result correctly.

3. Final Answer:

   The base case condition should be start === s.length, not start > s.length -> Option C

4. Quick Check:

   Base case triggers at string end index [OK]

Hint: Base case must match string length exactly to save partitions [OK]

Common Mistakes:

• Using > instead of === for base case
• Not pushing a copy of path (but not asked here)
• Starting loop incorrectly at start instead of start+1

5. Given the string "racecar", how many palindrome partitions will the backtracking algorithm find?

hard

A. 8

B. 6

C. 4

D. 10

Solution

1. Step 1: Identify palindrome substrings in 'racecar'

   Palindromes include all single characters 'r','a','c','e','c','a','r'; 'cec' (indices 2-4); 'aceca' (1-5); 'racecar' (whole).

2. Step 2: Count all palindrome partitions

   Valid partitions: ['racecar'], ['r','aceca','r'], ['r','a','cec','a','r'], ['r','a','c','e','c','a','r'], and others. Total 10.

3. Final Answer:

   10 -> Option D

4. Quick Check:

   Backtracking finds 10 palindrome partitions for 'racecar' [OK]

Hint: Count all palindrome splits including nested palindromes [OK]

Common Mistakes:

• Counting only single-character partitions
• Missing larger palindrome substrings like 'aceca'
• Assuming only 1 or 2 partitions exist