Palindrome Partitioning Using Backtracking in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Palindrome Partitioning for 'aab'

What is the output of the following Go code that finds all palindrome partitions of the string 'aab'?

DSA Go

package main

import (
	"fmt"
)

func isPalindrome(s string) bool {
	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
		if s[i] != s[j] {
			return false
		}
	}
	return true
}

func backtrack(s string, start int, path []string, res *[][]string) {
	if start == len(s) {
		temp := make([]string, len(path))
		copy(temp, path)
		*res = append(*res, temp)
		return
	}
	for end := start + 1; end <= len(s); end++ {
		if isPalindrome(s[start:end]) {
			backtrack(s, end, append(path, s[start:end]), res)
		}
	}
}

func partition(s string) [][]string {
	var res [][]string
	backtrack(s, 0, []string{}, &res)
	return res
}

func main() {
	result := partition("aab")
	fmt.Println(result)
}

A [["aab"]]

B [["aa", "bb"]]

C [["a", "a", "b"], ["aa", "b"]]

D [["a", "ab"]]

💡 Hint

Think about all ways to split the string where each part is a palindrome.

The code finds all partitions of 'aab' where each substring is a palindrome. 'a', 'a', 'b' and 'aa', 'b' are the valid palindrome partitions.

🧠 Conceptual

intermediate

Understanding Backtracking in Palindrome Partitioning

Which statement best describes the role of backtracking in palindrome partitioning?

A Backtracking merges all substrings into one palindrome.

B Backtracking only checks the first partition and stops.

C Backtracking sorts the string before partitioning.

D Backtracking tries all possible partitions and discards those that are not palindromes.

💡 Hint

Backtracking explores all options but only keeps valid ones.

Backtracking explores all substring partitions and only keeps those where each substring is a palindrome, discarding others.

🔧 Debug

advanced

Identify the Error in Palindrome Partitioning Code

What error will the following Go code produce when run?

DSA Go

package main

import "fmt"

func isPalindrome(s string) bool {
	for i := 0; i < len(s)/2; i++ {
		if s[i] != s[len(s)-i-1] {
			return false
		}
	}
	return true
}

func main() {
	fmt.Println(isPalindrome("abba"))
}

A Index out of range runtime error

B Returns false incorrectly

C Returns true correctly

D Compilation error

💡 Hint

Check the index used for the right side character.

The code uses s[len(s)-i] which is out of range because string indices go from 0 to len(s)-1.

🚀 Application

advanced

Number of Palindrome Partitions for 'racecar'

How many palindrome partitions does the string 'racecar' have?

A 8

B 4

C 6

D 10

💡 Hint

Consider all ways to split 'racecar' into palindromes like 'r', 'a', 'cec', 'a', 'r'.

The string 'racecar' has 8 palindrome partitions including single letters and larger palindromes like 'cec' and 'aceca'.

❓ Predict Output

expert

Output of Palindrome Partitioning with Memoization

What is the output of the following Go code that uses memoization to optimize palindrome partitioning for 'aaa'?

DSA Go

package main

import "fmt"

func isPalindrome(s string) bool {
	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
		if s[i] != s[j] {
			return false
		}
	}
	return true
}

func backtrack(s string, start int, memo map[int][][]string) [][]string {
	if val, ok := memo[start]; ok {
		return val
	}
	var res [][]string
	if start == len(s) {
		return [][]string{{}}
	}
	for end := start + 1; end <= len(s); end++ {
		if isPalindrome(s[start:end]) {
			for _, sub := range backtrack(s, end, memo) {
				partition := append([]string{s[start:end]}, sub...)
				res = append(res, partition)
			}
		}
	}
	memo[start] = res
	return res
}

func partition(s string) [][]string {
	memo := make(map[int][][]string)
	return backtrack(s, 0, memo)
}

func main() {
	result := partition("aaa")
	fmt.Println(result)
}

A [["aaa"]]

B [["a", "a", "a"], ["a", "aa"], ["aa", "a"], ["aaa"]]

C [["a", "a", "a"]]

D [["a", "aa"], ["aa", "a"]]

💡 Hint

Memoization caches results to avoid repeated work.

The code returns all palindrome partitions of 'aaa' including single letters, pairs, and the whole string.

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 reverse a string using recursion

D. To split a string into all possible palindrome substrings

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 D

4. Quick Check:

   Palindrome partitioning = all palindrome splits [OK]

Hint: Backtracking tries all splits to find palindrome partitions [OK]

Common Mistakes:

• Confusing palindrome partitioning with finding longest palindrome
• Thinking it only finds one partition instead of all
• Mixing palindrome check with string reversal

2. Which of the following Go function signatures correctly represents a helper function for palindrome partitioning backtracking?

easy

A. func backtrack(s string, start int, path []string, result *[][]string)

B. func backtrack(s int, start string, path []int, result [][]string)

C. func backtrack(s string, path int, start []string, result [][]string)

D. func backtrack(s []string, start int, path string, result *[][]string)

Solution

1. Step 1: Analyze parameter types

   The string to partition is 's string', start index is 'int', current path is '[]string', and result is pointer to slice of slices of strings.

2. Step 2: Match correct signature

   func backtrack(s string, start int, path []string, result *[][]string) matches all types correctly for backtracking palindrome partitioning.

3. Final Answer:

   func backtrack(s string, start int, path []string, result *[][]string) -> Option A

4. Quick Check:

   Correct parameter types = func backtrack(s string, start int, path []string, result *[][]string) [OK]

Hint: Check parameter types: string, int, slice, pointer to result [OK]

Common Mistakes:

• Mixing parameter order or types
• Using non-pointer for result when modification needed
• Confusing path and start parameter types

3. What is the output of the following Go code snippet?

package main
import "fmt"

func isPalindrome(s string) bool {
    for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
        if s[i] != s[j] {
            return false
        }
    }
    return true
}

func backtrack(s string, start int, path []string, result *[][]string) {
    if start == len(s) {
        temp := make([]string, len(path))
        copy(temp, path)
        *result = append(*result, temp)
        return
    }
    for end := start + 1; end <= len(s); end++ {
        if isPalindrome(s[start:end]) {
            backtrack(s, end, append(path, s[start:end]), result)
        }
    }
}

func partition(s string) [][]string {
    var result [][]string
    backtrack(s, 0, []string{}, &result)
    return result
}

func main() {
    res := partition("aab")
    fmt.Println(res)
}

medium

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

B. [["aab"]]

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

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

Solution

1. Step 1: Check palindrome substrings of "aab"

   "a" is palindrome, "aa" is palindrome, "b" is palindrome, "ab" is not palindrome.

2. Step 2: Backtracking partitions

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

3. Final Answer:

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

4. Quick Check:

   All palindrome partitions = [["a", "a", "b"], ["aa", "b"]] [OK]

Hint: Check all palindrome splits, ignore non-palindromes [OK]

Common Mistakes:

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

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

func isPalindrome(s string) bool {
    for i := 0; i < len(s)/2; i++ {
        if s[i] != s[len(s)-i] {
            return false
        }
    }
    return true
}

medium

A. Missing return statement

B. Incorrect loop condition, should be i <= len(s)/2

C. Index out of range error due to s[len(s)-i]

D. No bug, code is correct

Solution

1. Step 1: Analyze index usage in palindrome check

   Index s[len(s)-i] is out of range because last index is len(s)-1, not len(s).

2. Step 2: Correct index to s[len(s)-1-i]

   Subtract 1 from len(s) to avoid out of range error.

3. Final Answer:

   Index out of range error due to s[len(s)-i] -> Option C

4. Quick Check:

   Index error = Index out of range error due to s[len(s)-i] [OK]

Hint: Last index is len(s)-1, not len(s) [OK]

Common Mistakes:

• Using len(s)-i instead of len(s)-1-i
• Ignoring index out of range panic
• Assuming loop condition fixes index error

5. Given the string "racecar", how many palindrome partitions will the backtracking algorithm find? Consider all possible partitions where each substring is a palindrome.

hard

A. 4

B. 8

C. 6

D. 10

Solution

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

   Palindromes include all single characters, "cec" (indices 2-4), "aceca" (1-5), "racecar" (0-6).

2. Step 2: List all palindrome partitions

   Partitions are: ["r", "a", "c", "e", "c", "a", "r"], ["r", "a", "cec", "a", "r"], ["r", "aceca", "r"], ["racecar"], ["r", "a", "c", "ece", "a", "r"], ["r", "a", "c", "e", "c", "a", "r"] (already counted), and others totaling 8 unique partitions.

3. Final Answer:

   8 -> Option B

4. Quick Check:

   Count all palindrome partitions = 8 [OK]

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

Common Mistakes:

• Counting only single character partitions
• Missing longer palindrome substrings like "aceca"
• Including invalid partitions like "ece"