Palindrome Detection in DSA Go - Build from Scratch

Palindrome Detection

📖 Scenario: Imagine you are building a simple program to check if a word is a palindrome. A palindrome is a word that reads the same forwards and backwards, like "level" or "radar". This is useful in games, puzzles, or text analysis.

🎯 Goal: You will create a program that checks if a given word is a palindrome by comparing characters from the start and end.

📋 What You'll Learn

Create a string variable with a specific word

Create a variable to hold the length of the string

Use a loop to compare characters from start and end

Print whether the word is a palindrome or not

💡 Why This Matters

🌍 Real World

Palindrome detection is used in text processing, data validation, and puzzle games to identify symmetrical patterns.

💼 Career

Understanding string manipulation and loops is fundamental for software development, especially in tasks involving text analysis and algorithm design.

1

Create the word to check

Create a string variable called word and set it to the exact value "racecar".

DSA Go

var word string = ""
// Your code here

Hint

Use var word string = "racecar" to create the word.

2

Get the length of the word

Create an integer variable called length and set it to the length of word using len(word).

DSA Go

package main

import "fmt"

func main() {
    var word string = "racecar"
    var length int
    // Your code here
}

Hint

Use var length int = len(word) to get the length.

3

Check if the word is a palindrome

Create a boolean variable called isPalindrome and set it to true. Then use a for loop with i from 0 to length/2 (exclusive). Inside the loop, compare word[i] and word[length-1-i]. If they are not equal, set isPalindrome to false and break the loop.

DSA Go

package main

import "fmt"

func main() {
    var word string = "racecar"
    var length int = len(word)
    var isPalindrome bool = true
    // Your code here
}

Hint

Use a for loop from 0 to length/2 and compare characters at i and length-1-i.

4

Print the result

Use fmt.Println to print "Palindrome" if isPalindrome is true, otherwise print "Not Palindrome".

DSA Go

package main

import "fmt"

func main() {
    var word string = "racecar"
    var length int = len(word)
    var isPalindrome bool = true
    for i := 0; i < length/2; i++ {
        if word[i] != word[length-1-i] {
            isPalindrome = false
            break
        }
    }
    // Your code here
}

Hint

Use if isPalindrome { fmt.Println("Palindrome") } else { fmt.Println("Not Palindrome") }.

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