Valid Palindrome Two Pointer in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the left pointer at the start of the string.

DSA Go

left := [1]

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

A0

Blen(s) - 1

C1

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Starting left pointer at the end of the string.

Using negative index which is invalid.

The left pointer should start at index 0 to begin checking from the start of the string.

2fill in blank

medium

Complete the code to initialize the right pointer at the end of the string.

DSA Go

right := [1]

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

Alen(s)

B0

Clen(s) - 1

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using len(s) as index which is out of range.

Starting right pointer at 0 which is the start.

The right pointer should start at the last index, which is length of string minus one.

3fill in blank

hard

Fix the error in the condition to skip non-alphanumeric characters on the left pointer.

DSA Go

for left < right && !isAlphanumeric(s[[1]]) {
    left++
}

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

Aleft

B0

Cright

Dlen(s)

Attempts:

3 left

💡 Hint

Common Mistakes

Using right pointer index inside left pointer loop.

Using fixed index like 0 or len(s) which causes errors.

We check the character at the left pointer index to skip non-alphanumeric characters.

4fill in blank

hard

Fill both blanks to skip non-alphanumeric characters on both pointers.

DSA Go

for left < right && !isAlphanumeric(s[[1]]) {
    left++
}
for left < right && !isAlphanumeric(s[[2]]) {
    right--
}

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

Aleft

Bright

C0

Dlen(s) - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using same pointer for both loops.

Using fixed indices instead of pointers.

Use left pointer index for the first loop and right pointer index for the second loop to skip invalid characters.

5fill in blank

hard

Fill all three blanks to compare characters ignoring case and move pointers accordingly.

DSA Go

if strings.ToLower(string(s[[1]])) != strings.ToLower(string(s[[2]])) {
    return false
}
[3]++
right--

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

Aleft

Bright

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing wrong indices.

Not moving pointers after comparison.

Compare characters at left and right pointers ignoring case, then move left pointer forward and right pointer backward.

Practice

1. What does the two-pointer technique check when verifying if a string is a palindrome?

easy

A. It compares characters from the start and end moving towards the center

B. It counts the number of vowels in the string

C. It reverses the string and compares with the original

D. It sorts the characters and checks if sorted equals original

Solution

1. Step 1: Understand two-pointer approach

   The two-pointer technique uses two indexes: one at the start and one at the end of the string.

2. Step 2: Compare characters moving inward

   It compares characters at these pointers and moves them towards the center to check if they match.

3. Final Answer:

   It compares characters from the start and end moving towards the center -> Option A

4. Quick Check:

   Two-pointer = compare start/end chars [OK]

Hint: Check characters from both ends moving inward [OK]

Common Mistakes:

• Thinking it counts vowels instead of comparing characters
• Assuming it reverses the string explicitly
• Confusing sorting with palindrome check

2. Which of the following Go code snippets correctly initializes two pointers for a palindrome check on string s?

easy

A. left := len(s); right := 0

B. left := 1; right := len(s)

C. left := -1; right := len(s) + 1

D. left := 0; right := len(s) - 1

Solution

1. Step 1: Identify valid pointer initialization

   For a string, the first character index is 0 and last is length minus 1.

2. Step 2: Check each option

   left := 0; right := len(s) - 1 correctly sets left to 0 and right to len(s)-1, valid for two-pointer palindrome check.

3. Final Answer:

   left := 0; right := len(s) - 1 -> Option D

4. Quick Check:

   Start=0, End=len(s)-1 [OK]

Hint: Start left at 0 and right at len(s)-1 [OK]

Common Mistakes:

• Starting left at 1 instead of 0
• Setting right to len(s) which is out of range
• Using negative or invalid indices

3. What will be the output of the following Go code?

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
}

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

medium

A. true\nfalse

B. false\ntrue

C. true\ntrue

D. false\nfalse

Solution

1. Step 1: Trace "racecar" input

   Characters at start and end match moving inward, so function returns true.

2. Step 2: Trace "hello" input

   Characters 'h' and 'o' differ at first check, so function returns false.

3. Final Answer:

   true\nfalse -> Option A

4. Quick Check:

   "racecar" palindrome = true, "hello" not = false [OK]

Hint: Check first and last chars; mismatch means false [OK]

Common Mistakes:

• Assuming "hello" is palindrome
• Confusing return values order
• Ignoring early return on mismatch

4. Identify the bug in this Go function that checks palindrome:

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

medium

A. left should start at 1, not 0

B. The loop condition should be left <= right

C. right should be initialized to len(s)-1, not len(s)

D. The function should return false at the end

Solution

1. Step 1: Check pointer initialization

   right is set to len(s), which is out of string index range (0 to len(s)-1).

2. Step 2: Correct initialization

   right should be len(s)-1 to point to last character correctly.

3. Final Answer:

   right should be initialized to len(s)-1, not len(s) -> Option C

4. Quick Check:

   Index out of range error fixed by right = len(s)-1 [OK]

Hint: Set right pointer to len(s)-1 to avoid index error [OK]

Common Mistakes:

• Using len(s) as index causes runtime error
• Changing left pointer start incorrectly
• Misunderstanding loop condition

5. Given the string s = "A man, a plan, a canal: Panama", which modification to the two-pointer palindrome check is needed to correctly identify it as a palindrome?

hard

A. Reverse the string and compare directly

B. Ignore non-alphanumeric characters and compare case-insensitively

C. Only compare vowels in the string

D. Convert string to uppercase and compare characters directly

Solution

1. Step 1: Understand input complexity

   The string contains spaces, commas, and mixed cases which should be ignored for palindrome check.

2. Step 2: Modify two-pointer logic

   Skip non-alphanumeric characters and compare characters in lowercase to handle case differences.

3. Final Answer:

   Ignore non-alphanumeric characters and compare case-insensitively -> Option B

4. Quick Check:

   Clean and lowercase string before two-pointer check [OK]

Hint: Skip symbols and compare lowercase chars [OK]

Common Mistakes:

• Not ignoring spaces and punctuation
• Comparing case-sensitively causing false negatives
• Only converting case without skipping symbols