Palindrome Detection in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Palindrome Check Function

What is the output of the following Go code that checks if a string is a palindrome?

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)-1-i] {
			return false
		}
	}
	return true
}
func main() {
	fmt.Println(isPalindrome("radar"))
	fmt.Println(isPalindrome("hello"))
}

A

false
false

B

false
true

C

true
true

D

true
false

💡 Hint

Check character pairs from start and end moving towards the center.

The function compares characters from the start and end. 'radar' reads the same forwards and backwards, so true. 'hello' does not, so false.

🧠 Conceptual

intermediate

Understanding Palindrome Detection Logic

Which statement best describes the logic used to detect a palindrome in a string?

A Compare characters from the start and end moving towards the center, returning false if any pair differs.

B Reverse the string and compare it to the original string, returning true if they differ.

C Check if the string length is even and return true if it is.

D Count the number of vowels and return true if it is equal to the number of consonants.

💡 Hint

Think about how to verify if a string reads the same forwards and backwards.

The palindrome check compares characters from both ends towards the center. If any pair is different, it is not a palindrome.

❓ Predict Output

advanced

Output of Palindrome Check with Unicode Characters

What is the output of this Go code that checks if a string with Unicode characters is a palindrome?

DSA Go

package main
import (
	"fmt"
)
func isPalindrome(s string) bool {
	runes := []rune(s)
	for i := 0; i < len(runes)/2; i++ {
		if runes[i] != runes[len(runes)-1-i] {
			return false
		}
	}
	return true
}
func main() {
	fmt.Println(isPalindrome("あいいあ"))
	fmt.Println(isPalindrome("あいえあ"))
}

A

false
false

B

false
true

C

true
false

D

true
true

💡 Hint

Use rune slices to handle Unicode characters correctly.

The code converts the string to runes to handle Unicode properly. 'あいいあ' is a palindrome, 'あいえあ' is not.

🔧 Debug

advanced

Identify the Error in Palindrome Function

What error will this Go code produce when checking if a string is a palindrome?

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)-1-i] {
			return false
		}
	}
	return true
}
func main() {
	fmt.Println(isPalindrome("level"))
}

A runtime error: index out of range

B compiles and prints true

C compiles and prints false

D syntax error

💡 Hint

Simulate the loop indices for 'level' (length 5).

The code compiles and prints true. The loop condition i <= len(s)/2 works because indices stay within bounds; for odd lengths, the middle character compares to itself.

🚀 Application

expert

Count Palindromic Substrings in a String

Given the string "abba", how many palindromic substrings does it contain?

A 6

B 8

C 7

D 9

💡 Hint

Consider all substrings and count those that read the same forwards and backwards.

Palindromic substrings: 'a'(0-0), 'b'(1-1), 'b'(2-2), 'a'(3-3), 'bb'(1-2), 'abba'(0-3). Total 6.

Practice

1. What does a palindrome string mean in simple terms?

easy

A. A string with all unique characters

B. A string that contains only vowels

C. A string that reads the same forwards and backwards

D. A string that ends with a special character

Solution

1. Step 1: Understand palindrome definition

   A palindrome is a word or phrase that reads the same from left to right and right to left.

2. Step 2: Match options with definition

   A string that reads the same forwards and backwards matches this definition exactly, others describe different string properties.

3. Final Answer:

   A string that reads the same forwards and backwards -> Option C

4. Quick Check:

   Palindrome = Same forwards and backwards [OK]

Hint: Check if string equals its reverse [OK]

Common Mistakes:

• Confusing palindrome with unique characters
• Thinking palindrome means only vowels
• Assuming palindrome ends with special character

2. Which Go code snippet correctly checks if a string s is a palindrome?

easy

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

B. for i := 0; i < len(s); i++ { if s[i] == s[i+1] { return true } } return false

C. for i := 0; i < len(s)/2; i++ { if s[i] == s[len(s)-1-i] { return false } } return true

D. for i := 0; i < len(s); i++ { if s[i] != s[i] { return false } } return true

Solution

1. Step 1: Analyze palindrome check logic

   We compare characters from start and end moving towards center. If any pair differs, return false.

2. Step 2: Match code with logic

   for i := 0; i < len(s)/2; i++ { if s[i] != s[len(s)-1-i] { return false } } return true correctly compares s[i] with s[len(s)-1-i] for half the string length and returns false if mismatch found.

3. Final Answer:

   for i := 0; i < len(s)/2; i++ { if s[i] != s[len(s)-1-i] { return false } } return true -> Option A

4. Quick Check:

   Compare pairs from ends = for i := 0; i < len(s)/2; i++ { if s[i] != s[len(s)-1-i] { return false } } return true [OK]

Hint: Compare characters from ends to middle [OK]

Common Mistakes:

• Checking only adjacent characters
• Returning false when characters match
• Comparing character with itself incorrectly

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

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

fmt.Println(isPalindrome("level"))
fmt.Println(isPalindrome("hello"))

medium

A. false false

B. false true

C. true true

D. true false

Solution

1. Step 1: Check "level" palindrome

   "level" reads same forwards and backwards, so function returns true.

2. Step 2: Check "hello" palindrome

   "hello" reversed is "olleh", different, so function returns false.

3. Final Answer:

   true false -> Option D

4. Quick Check:

   "level"=true, "hello"=false [OK]

Hint: Test string and its reverse equality [OK]

Common Mistakes:

• Assuming all strings are palindrome
• Mixing output order
• Ignoring case sensitivity

4. Find the error in this Go function that checks palindrome:

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

medium

A. The loop condition should be 'i < len(s)/2' to avoid index out of range

B. The comparison should be 's[i] == s[len(s)-1-i]' to return true early

C. The function should return false at the end instead of true

D. The loop should start from 'i := 1' instead of 0

Solution

1. Step 1: Analyze loop boundary

   The loop uses 'i <= len(s)/2', which causes 'i' to reach len(s)/2 inclusive, possibly exceeding index for odd length strings.

2. Step 2: Correct loop condition

   Changing to 'i < len(s)/2' ensures no index out of range error and proper comparison only up to middle.

3. Final Answer:

   The loop condition should be 'i < len(s)/2' to avoid index out of range -> Option A

4. Quick Check:

   Loop boundary off by one causes error [OK]

Hint: Use '<' not '<=' for half-length loops [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Returning wrong boolean at end
• Starting loop from 1 instead of 0

5. You want to detect if a string is a palindrome ignoring case and spaces. Which approach is best in Go?

hard

A. Check palindrome directly without changes

B. Remove spaces, convert to lowercase, then check palindrome normally

C. Only convert to lowercase, ignore spaces

D. Reverse string and compare without any changes

Solution

1. Step 1: Understand problem requirements

   We must ignore spaces and case differences when checking palindrome.

2. Step 2: Prepare string correctly

   Removing spaces and converting all letters to lowercase normalizes the string for accurate palindrome check.

3. Step 3: Check palindrome

   After normalization, use standard palindrome check comparing characters from ends.

4. Final Answer:

   Remove spaces, convert to lowercase, then check palindrome normally -> Option B

5. Quick Check:

   Normalize string before check = Remove spaces, convert to lowercase, then check palindrome normally [OK]

Hint: Clean string first: lowercase + remove spaces [OK]

Common Mistakes:

• Ignoring spaces in palindrome check
• Not converting to lowercase
• Comparing raw strings directly