Palindrome Detection in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if a string is a palindrome by comparing characters from start and end.

DSA Go

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

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

A1

Bi

C0

Dlen(s)

Attempts:

3 left

💡 Hint

Common Mistakes

Using len(s) instead of len(s)-1 for the last index.

Comparing characters without subtracting i from the end index.

The index from the end is calculated as len(s)-1-i to compare characters from both ends.

2fill in blank

medium

Complete the code to convert a string to lowercase before checking palindrome.

DSA Go

import "strings"

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

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

AToLower

BToUpper

CTrimSpace

DReplace

Attempts:

3 left

💡 Hint

Common Mistakes

Using ToUpper instead of ToLower (still works but inconsistent with example).

Not converting case at all, causing false negatives.

Using strings.ToLower converts the string to lowercase, ensuring case-insensitive palindrome check.

3fill in blank

hard

Fix the error in the code to correctly ignore non-alphanumeric characters when checking palindrome.

DSA Go

import (
    "strings"
    "unicode"
)

func isPalindrome(s string) bool {
    filtered := ""
    for _, r := range s {
        if unicode.IsLetter(r) || unicode.IsDigit(r) {
            filtered += strings.ToLower(string([1]))
        }
    }
    for i := 0; i < len(filtered)/2; i++ {
        if filtered[i] != filtered[len(filtered)-1-i] {
            return false
        }
    }
    return true
}

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

Ai

Bfiltered

Cr

Ds

Attempts:

3 left

💡 Hint

Common Mistakes

Using the whole string instead of the current character.

Appending the loop index instead of the character.

The variable r represents the current rune (character) in the loop and should be converted to lowercase and added.

4fill in blank

hard

Fill both blanks to create a map of characters and their counts from a string.

DSA Go

func charCountMap(s string) map[rune]int {
    counts := make(map[rune]int)
    for _, [1] := range s {
        counts[[2]]++
    }
    return counts
}

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

Ach

Bi

Dr

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names in the loop and map access.

Using the index variable instead of the character.

The loop variable ch represents each character, which is used as the key in the map to count occurrences.

5fill in blank

hard

Fill all three blanks to create a palindrome check ignoring case and non-alphanumeric characters.

DSA Go

import (
    "strings"
    "unicode"
)

func isPalindrome(s string) bool {
    filtered := ""
    for _, [1] := range s {
        if unicode.IsLetter([2]) || unicode.IsDigit([3]) {
            filtered += strings.ToLower(string(ch))
        }
    }
    for i := 0; i < len(filtered)/2; i++ {
        if filtered[i] != filtered[len(filtered)-1-i] {
            return false
        }
    }
    return true
}

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

Ach

Dr

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names causing compilation errors.

Not using the loop variable in the conditions.

Use the same variable ch to represent the current character in the loop and in the checks.

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