Longest Palindromic Substring in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the longest palindrome length to 1.

DSA Go

longest := [1]

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

A1

B0

C-1

Dlen(s)

Attempts:

3 left

💡 Hint

Common Mistakes

Setting longest to 0 causes errors when checking substrings.

Using len(s) assumes the whole string is palindrome initially.

The minimum length of a palindrome substring is 1 (a single character).

2fill in blank

medium

Complete the code to expand around the center indices left and right.

DSA Go

for left >= 0 && right < len(s) && s[left] == s[right] {
    left--
    right++
}
start := left + 1
end := right - 1
length := [1]

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

Aright - left - 1

Bend - start + 1

Cright - left

Dend - start

Attempts:

3 left

💡 Hint

Common Mistakes

Using right - left without adjustment gives incorrect length.

Using end - start misses the inclusive nature of indices.

The length of the palindrome is end - start + 1 because both start and end are inclusive indices.

3fill in blank

hard

Fix the error in the palindrome check condition inside the loop.

DSA Go

for i := 0; i < len(s); i++ {
    l, r := i, i+1
    for l >= 0 && r < len(s) && s[l] [1] s[r] {
        l--
        r++
    }
}

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

A>

B!=

C<

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' causes the loop to break immediately.

Using '<' or '>' is incorrect for character equality check.

We expand while characters at l and r are equal to find palindromes.

4fill in blank

hard

Fill both blanks to update the longest palindrome substring start and length.

DSA Go

if length > longest {
    longest = length
    startIndex = [1]
    endIndex = [2]
}

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

Astart

Bend

Ci

Dlength

Attempts:

3 left

💡 Hint

Common Mistakes

Using i instead of start or end causes incorrect substring tracking.

Assigning length to indices is a type mismatch.

We update startIndex to start and endIndex to end to track the longest palindrome boundaries.

5fill in blank

hard

Fill all three blanks to return the longest palindromic substring from s.

DSA Go

return s[[1]:[2]+[3]]

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

AstartIndex

BendIndex

C1

Dlongest

Attempts:

3 left

💡 Hint

Common Mistakes

Not adding 1 to endIndex excludes the last character.

Using longest instead of indices causes slicing errors.

Slice from startIndex to endIndex + 1 to include the last character of the palindrome.

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