Palindrome Partitioning Using Backtracking in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

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

DSA Java

private boolean isPalindrome(String s, int left, int right) {
    while (left < right) {
        if (s.charAt(left) != s.charAt([1])) {
            return false;
        }
        left++;
        right--;
    }
    return true;
}

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

Aleft

Bright

Cleft + 1

Dright - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using left + 1 or right - 1 instead of right causes wrong character comparison.

Comparing s.charAt(left) with s.charAt(left) always returns true.

We compare characters at positions 'left' and 'right' to check palindrome. So s.charAt(right) is correct.

2fill in blank

medium

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

DSA Java

List<String> current = new ArrayList<>();
String s = "aab";
int start = 0, end = 1;
current.add(s.substring([1], end + 1));

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

Aend

B0

Cstart

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using end as start index causes wrong substring extraction.

Using 0 or 1 as start index ignores the actual start position.

substring(start, end + 1) extracts substring from start to end inclusive.

3fill in blank

hard

Fix the error in the backtracking recursive call to explore next partitions.

DSA Java

private void backtrack(String s, int start, List<String> current, List<List<String>> result) {
    if (start == s.length()) {
        result.add(new ArrayList<>(current));
        return;
    }
    for (int end = start; end < s.length(); end++) {
        if (isPalindrome(s, start, end)) {
            current.add(s.substring(start, end + 1));
            backtrack(s, [1], current, result);
            current.remove(current.size() - 1);
        }
    }
}

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

Astart + 1

Bstart

Cend

Dend + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using start + 1 causes infinite recursion or wrong partitions.

Using end causes overlapping substrings.

After choosing substring s[start:end], next start index is end + 1 to avoid overlap.

4fill in blank

hard

Fill both blanks to complete the main function that starts backtracking and returns all partitions.

DSA Java

public List<List<String>> partition(String s) {
    List<List<String>> result = new ArrayList<>();
    List<String> current = new ArrayList<>();
    [1](s, 0, current, result);
    return [2];
}

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

Abacktrack

Bpartition

Cresult

Dcurrent

Attempts:

3 left

💡 Hint

Common Mistakes

Returning current instead of result returns incomplete data.

Calling partition recursively causes stack overflow.

Call backtrack to fill result, then return result list.

5fill in blank

hard

Fill all three blanks to create a map comprehension that stores substring lengths for palindromes.

DSA Java

Map<String, Integer> palindromeLengths = new HashMap<>();
for (int i = 0; i < s.length(); i++) {
    for (int j = i; j < s.length(); j++) {
        if ([1](s, i, j)) {
            palindromeLengths.put(s.[2](i, j + 1), j - i + [3]);
        }
    }
}

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

AisPalindrome

Bsubstring

C1

Dlength

Attempts:

3 left

💡 Hint

Common Mistakes

Using length instead of substring causes errors.

Not adding 1 to length calculation gives wrong length.

Use isPalindrome to check, substring to get string, length calculation adds 1 for inclusive end.

Practice

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

easy

A. To count the number of palindromes in a string

B. To find the longest palindrome substring in a string

C. To split a string into all possible palindrome substrings

D. To reverse the string and check if it is a palindrome

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 into palindrome parts.

3. Final Answer:

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

4. Quick Check:

   Palindrome partitioning = splitting into palindrome substrings [OK]

Hint: Backtracking explores all palindrome splits [OK]

Common Mistakes:

• Confusing palindrome partitioning with longest palindrome substring
• Thinking it only counts palindromes instead of listing partitions
• Assuming it reverses the whole string

2. Which of the following is the correct Java method signature for a backtracking function that partitions a string into palindromes?

easy

A. boolean backtrack(String s, int start, List<String> current)

B. void backtrack(String s, int start, List result, List<String> current)

C. int backtrack(String s, int start, List<String> result)

D. String backtrack(String s, int start, List result)

Solution

1. Step 1: Analyze method parameters

   The method needs the string, current start index, a list to store all partitions, and the current partition path.

2. Step 2: Check return type

   Backtracking methods usually return void because they build results via parameters.

3. Final Answer:

   void backtrack(String s, int start, List result, List<String> current) -> Option B

4. Quick Check:

   Backtracking method returns void and uses lists [OK]

Hint: Backtracking returns void and uses lists for results [OK]

Common Mistakes:

• Using wrong return type like int or boolean
• Missing current partition list parameter
• Returning String instead of void

3. What will be the output partitions for the input string "aab" using palindrome partitioning?

medium

A. [["aab"]]

B. [["aa", "ab"]]

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

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

Solution

1. Step 1: Identify palindrome substrings

   "a" and "aa" are palindromes; "b" is a palindrome; "ab" is not.

2. Step 2: List all palindrome partitions

   Partitions are ["a", "a", "b"] and ["aa", "b"].

3. Final Answer:

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

4. Quick Check:

   Only palindrome splits included [OK]

Hint: Check each substring palindrome before partitioning [OK]

Common Mistakes:

• Including non-palindrome substrings like "ab"
• Missing the partition with "aa"
• Returning only one partition

4. Identify the error in this Java backtracking snippet for palindrome partitioning:

void backtrack(String s, int start, List result, List<String> current) {
  if (start == s.length()) {
    result.add(current);
    return;
  }
  for (int end = start; end < s.length(); end++) {
    if (isPalindrome(s, start, end)) {
      current.add(s.substring(start, end + 1));
      backtrack(s, end + 1, result, current);
      current.remove(current.size());
    }
  }
}

medium

A. Incorrect removal index in current.remove()

B. Missing base case for empty string

C. Wrong substring indices in s.substring()

D. Backtracking call uses wrong start index

Solution

1. Step 1: Check removal from current list

   List indices start at 0, so removing at current.size() causes IndexOutOfBoundsException.

2. Step 2: Correct removal index

   Should remove last element with current.remove(current.size() - 1).

3. Final Answer:

   Incorrect removal index in current.remove() -> Option A

4. Quick Check:

   Remove last element with size()-1 [OK]

Hint: Remove last added element with size()-1 index [OK]

Common Mistakes:

• Removing element at size() instead of size()-1
• Confusing substring indices
• Incorrect recursive call start index

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

hard

A. 6

B. 8

C. 4

D. 10

Solution

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

   Palindromes include "r", "a", "c", "e", "cec", "aceca", "racecar" and their combinations.

2. Step 2: Count all palindrome partitions

   Partitions are:
   ["racecar"],
   ["r", "aceca", "r"],
   ["r", "a", "cec", "a", "r"],
   ["r", "a", "c", "e", "c", "a", "r"],
   and others including splits like ["r", "a", "c", "ec", "a", "r"] are invalid because "ec" is not palindrome.
   Counting all valid partitions, the total is 6.

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Count all palindrome partitions = 6 [OK]

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

Common Mistakes:

• Counting only single-character partitions
• Missing longer palindrome substrings
• Double counting partitions