Longest Palindromic Substring in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of longest palindromic substring length

What is the output of the following Go code that finds the length of the longest palindromic substring?

DSA Go

package main
import "fmt"

func longestPalindromeLength(s string) int {
    n := len(s)
    if n == 0 {
        return 0
    }
    maxLen := 1
    for i := 0; i < n; i++ {
        // Odd length palindrome
        l, r := i, i
        for l >= 0 && r < n && s[l] == s[r] {
            length := r - l + 1
            if length > maxLen {
                maxLen = length
            }
            l--
            r++
        }
        // Even length palindrome
        l, r = i, i+1
        for l >= 0 && r < n && s[l] == s[r] {
            length := r - l + 1
            if length > maxLen {
                maxLen = length
            }
            l--
            r++
        }
    }
    return maxLen
}

func main() {
    fmt.Println(longestPalindromeLength("babad"))
}

A 3

B 2

C 4

D 5

💡 Hint

Check palindromes like "bab" or "aba" inside the string.

The longest palindromic substrings in "babad" are "bab" and "aba", both length 3.

🧠 Conceptual

intermediate

Understanding palindrome expansion technique

Why does the algorithm check both odd and even length palindromes separately when finding the longest palindromic substring?

A Because odd length palindromes are always longer than even length ones.

B Because palindromes can have either a single center character or two center characters.

C Because even length palindromes do not exist in strings.

D Because checking only odd length palindromes is faster.

💡 Hint

Think about palindrome centers and symmetry.

Odd length palindromes have one center character, even length palindromes have two center characters. Both must be checked to find all palindromes.

❓ Predict Output

advanced

Output of longest palindromic substring

What is the output of this Go program that returns the longest palindromic substring itself?

DSA Go

package main
import "fmt"

func longestPalindrome(s string) string {
    n := len(s)
    if n == 0 {
        return ""
    }
    start, maxLen := 0, 1
    for i := 0; i < n; i++ {
        // Odd length
        l, r := i, i
        for l >= 0 && r < n && s[l] == s[r] {
            if r-l+1 > maxLen {
                start = l
                maxLen = r - l + 1
            }
            l--
            r++
        }
        // Even length
        l, r = i, i+1
        for l >= 0 && r < n && s[l] == s[r] {
            if r-l+1 > maxLen {
                start = l
                maxLen = r - l + 1
            }
            l--
            r++
        }
    }
    return s[start : start+maxLen]
}

func main() {
    fmt.Println(longestPalindrome("cbbd"))
}

A "c"

B "cbbd"

C "b"

D "bb"

💡 Hint

Look for the longest substring that reads the same forwards and backwards.

The longest palindromic substring in "cbbd" is "bb".

🔧 Debug

advanced

Identify the error in palindrome substring code

What error will this Go code produce when run?

DSA Go

package main
import "fmt"

func longestPalindrome(s string) string {
    n := len(s)
    start, maxLen := 0, 1
    for i := 0; i < n; i++ {
        l, r := i, i
        for l >= 0 && r < n && s[l] == s[r] {
            if r-l+1 > maxLen {
                start = l
                maxLen = r - l + 1
            }
            l--
            r++
        }
    }
    return s[start : start+maxLen]
}

func main() {
    fmt.Println(longestPalindrome(""))
}

A runtime error: slice bounds out of range

B prints empty string ""

C compiles but prints "" without error

D syntax error: missing return type

💡 Hint

What happens when input string is empty and you slice it?

When input is empty, maxLen is 1 but slicing s[0:1] causes out of range error.

🚀 Application

expert

Longest palindromic substring count in a large string

Given a string of length 1000 consisting of random letters, which approach is best to find the longest palindromic substring efficiently?

A Check all substrings with nested loops, O(n^3) time complexity.

B Use dynamic programming with O(n^2) time and space complexity.

C Use Manacher's algorithm with O(n) time complexity.

D Sort the string and find palindromes by grouping characters.

💡 Hint

Consider time complexity for large input strings.

Manacher's algorithm finds longest palindromic substring in linear time, best for large strings.

Practice

1. What is the main goal when finding the Longest Palindromic Substring in a given string?

easy

A. To find the longest continuous sequence of characters that reads the same backward and forward

B. To find the longest substring with all unique characters

C. To find the longest substring that contains only vowels

D. To find the longest substring that starts and ends with the same character

Solution

1. Step 1: Understand palindrome definition

   A palindrome reads the same backward and forward, like 'madam' or 'racecar'.

2. Step 2: Identify longest continuous palindrome

   The problem asks for the longest continuous substring that is a palindrome, not just any substring or character pattern.

3. Final Answer:

   To find the longest continuous sequence of characters that reads the same backward and forward -> Option A

4. Quick Check:

   Longest palindromic substring = continuous palindrome [OK]

Hint: Look for continuous sequences that mirror around center [OK]

Common Mistakes:

• Confusing substring with subsequence
• Looking for unique characters instead of palindrome
• Ignoring continuity of substring

2. Which of the following Go function signatures is correct for a function that returns the longest palindromic substring from a string s?

easy

A. func longestPalindrome(s int) string

B. func longestPalindrome(s string) string

C. func longestPalindrome(s string) int

D. func longestPalindrome() string

Solution

1. Step 1: Check input parameter type

   The input should be a string to find its palindromic substring, so parameter type must be string.

2. Step 2: Check return type

   The function returns the longest palindromic substring, which is a string, so return type must be string.

3. Final Answer:

   func longestPalindrome(s string) string -> Option B

4. Quick Check:

   Input string, output string [OK]

Hint: Input and output both are strings for palindrome substring [OK]

Common Mistakes:

• Using wrong input type like int
• Returning int instead of string
• Missing input parameter

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

package main
import "fmt"

func longestPalindrome(s string) string {
    start, maxLen := 0, 1
    for i := 0; i < len(s); i++ {
        for j := i; j < len(s); j++ {
            sub := s[i : j+1]
            if isPalindrome(sub) && len(sub) > maxLen {
                start = i
                maxLen = len(sub)
            }
        }
    }
    return s[start : start+maxLen]
}

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

func main() {
    fmt.Println(longestPalindrome("babad"))
}

medium

A. "bab"

B. "aba"

C. "bad"

D. "babad"

Solution

1. Step 1: Understand the code logic

   The code checks all substrings and updates the longest palindrome found. For "babad", "bab" and "aba" are both palindromes of length 3.

2. Step 2: Check which palindrome is returned

   The code updates start and maxLen when a longer palindrome is found. It finds "bab" first and keeps it because "aba" comes later but has the same length, so "bab" remains.

3. Final Answer:

   "bab" -> Option A

4. Quick Check:

   First longest palindrome found = "bab" [OK]

Hint: Check first longest palindrome found in order [OK]

Common Mistakes:

• Assuming "aba" is returned instead of "bab"
• Thinking entire string is palindrome
• Ignoring substring length comparison

4. The following Go code attempts to find the longest palindromic substring but has a bug. What is the bug?

func longestPalindrome(s string) string {
    start, maxLen := 0, 1
    for i := 0; i < len(s); i++ {
        for j := i; j < len(s); j++ {
            sub := s[i:j]
            if isPalindrome(sub) && len(sub) > maxLen {
                start = i
                maxLen = len(sub)
            }
        }
    }
    return s[start : start+maxLen]
}

medium

A. The function isPalindrome is missing

B. The loop should start from j = i+1 instead of j = i

C. maxLen should be initialized to 0 instead of 1

D. The substring slice should be s[i:j+1] to include character at index j

Solution

1. Step 1: Check substring slicing

   In Go, s[i:j] excludes character at index j, so substring misses last character.

2. Step 2: Correct slicing to include last character

   Changing to s[i:j+1] includes character at j, ensuring full substring is checked.

3. Final Answer:

   The substring slice should be s[i:j+1] to include character at index j -> Option D

4. Quick Check:

   Substring slicing excludes last char if j not incremented [OK]

Hint: Remember Go slices exclude end index, use j+1 [OK]

Common Mistakes:

• Using s[i:j] misses last character
• Not adjusting loop indices accordingly
• Assuming isPalindrome is missing

5. Given the string s = "forgeeksskeegfor", which approach below efficiently finds the longest palindromic substring and what is that substring?

hard

A. Expand around center approach; longest palindrome is "forgeeksskeegfor"

B. Brute force checking all substrings; longest palindrome is "forgeeksskeegfor"

C. Dynamic programming with memoization; longest palindrome is "geeksskeeg"

D. Sorting characters and checking palindrome; longest palindrome is "ss"

Solution

1. Step 1: Identify efficient methods

   Dynamic programming stores palindrome info to avoid repeated checks, efficient for this problem.

2. Step 2: Find longest palindrome in given string

   "geeksskeeg" is the longest palindromic substring inside "forgeeksskeegfor"; entire string is not palindrome.

3. Final Answer:

   Dynamic programming with memoization; longest palindrome is "geeksskeeg" -> Option C

4. Quick Check:

   DP finds "geeksskeeg" efficiently [OK]

Hint: Use DP or expand center for efficient palindrome search [OK]

Common Mistakes:

• Assuming entire string is palindrome
• Using brute force which is slow
• Sorting characters breaks substring continuity