Palindrome Detection in DSA Go - Time & Space Complexity

Time Complexity: Palindrome Detection

O(n)

Understanding Time Complexity

We want to know how the time needed to check if a word or phrase is a palindrome changes as the input gets longer.

How does the number of steps grow when the input size grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

func isPalindrome(s string) bool {
    left, right := 0, len(s)-1
    for left < right {
        if s[left] != s[right] {
            return false
        }
        left++
        right--
    }
    return true
}
    

This code checks if a string reads the same forwards and backwards by comparing characters from both ends moving towards the center.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Comparing characters at positions from the start and end of the string.
• How many times: Up to half the length of the string (n/2 times).

How Execution Grows With Input

As the string gets longer, the number of character comparisons grows roughly half as fast.

Input Size (n)	Approx. Operations
10	5 comparisons
100	50 comparisons
1000	500 comparisons

Pattern observation: The number of steps grows linearly with input size, but only half as many comparisons are needed.

Final Time Complexity

Time Complexity: O(n)

This means the time to check a palindrome grows in direct proportion to the length of the string.

Common Mistake

[X] Wrong: "Checking a palindrome takes constant time because you only compare a few characters."

[OK] Correct: The number of comparisons depends on the string length, so longer strings need more checks, not just a few.

Interview Connect

Understanding how palindrome checking scales helps you explain your code clearly and shows you can analyze efficiency, a key skill in interviews.

Self-Check

"What if we changed the code to ignore spaces and punctuation? How would the time complexity change?"

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