Valid Palindrome Two Pointer in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Two Pointer Palindrome Check

What is the output of the following JavaScript code that checks if a string is a palindrome ignoring non-alphanumeric characters and case?

DSA Javascript

function isPalindrome(s) {
  let left = 0, right = s.length - 1;
  while (left < right) {
    while (left < right && !/[a-z0-9]/i.test(s[left])) left++;
    while (left < right && !/[a-z0-9]/i.test(s[right])) right--;
    if (s[left].toLowerCase() !== s[right].toLowerCase()) return false;
    left++;
    right--;
  }
  return true;
}

console.log(isPalindrome("A man, a plan, a canal: Panama"));

A SyntaxError

B false

C TypeError

D true

💡 Hint

Focus on how the code skips non-alphanumeric characters and compares letters ignoring case.

The code uses two pointers moving inward, skipping non-alphanumeric characters. It compares characters in lowercase. The input string is a famous palindrome phrase, so the function returns true.

❓ Predict Output

intermediate

Result of Palindrome Check on Non-Palindrome String

What does the following code print when checking if the string "race a car" is a palindrome?

DSA Javascript

function isPalindrome(s) {
  let left = 0, right = s.length - 1;
  while (left < right) {
    while (left < right && !/[a-z0-9]/i.test(s[left])) left++;
    while (left < right && !/[a-z0-9]/i.test(s[right])) right--;
    if (s[left].toLowerCase() !== s[right].toLowerCase()) return false;
    left++;
    right--;
  }
  return true;
}

console.log(isPalindrome("race a car"));

A false

B true

C ReferenceError

D RangeError

💡 Hint

Check the characters compared after skipping spaces.

The string "race a car" is not a palindrome when ignoring spaces and case, so the function returns false.

🧠 Conceptual

advanced

Why Use Two Pointers for Palindrome Check?

Why is the two-pointer technique efficient for checking if a string is a palindrome?

A It compares characters from both ends simultaneously, reducing the number of comparisons needed.

B It sorts the string first to check for palindrome properties.

C It uses recursion to check each character individually.

D It converts the string to a number and checks if the number is the same reversed.

💡 Hint

Think about how checking from both ends helps avoid unnecessary checks.

The two-pointer method compares characters from the start and end moving inward, which is efficient because it stops early if mismatch is found and only needs to check half the string.

🔧 Debug

advanced

Identify the Bug in Palindrome Code

What error will the following code produce when run, and why?

DSA Javascript

function isPalindrome(s) {
  let left = 0, right = s.length - 1;
  while (left < right) {
    while (left < right && !/[a-z0-9]/i.test(s[left])) left++
    while (left < right && !/[a-z0-9]/i.test(s[right])) right--;
    if (s[left].toLowerCase() !== s[right].toLowerCase()) return false;
    left++;
    right--;
  }
  return true;
}

console.log(isPalindrome("A man, a plan, a canal: Panama"));

A SyntaxError due to missing semicolon

B Runs correctly and returns true

C TypeError because s[left] is undefined

D ReferenceError due to undeclared variable

💡 Hint

JavaScript allows missing semicolons in many cases; check if code runs.

JavaScript automatically inserts semicolons in many cases, so missing semicolon after left++ does not cause an error. The code runs correctly and returns true.

🚀 Application

expert

Number of Palindromic Substrings Using Two Pointers

Given a string, how can you use the two-pointer technique to count all palindromic substrings efficiently?

A Use two pointers to split the string into halves and count palindromes in each half separately.

B Sort the string and count repeated characters as palindromes.

C Expand around each center (single character and between characters) using two pointers to count palindromes.

D Use two pointers to reverse the string and compare with original to count palindromes.

💡 Hint

Think about how palindromes can be centered at each character or between characters.

By expanding around each character and between characters with two pointers moving outward, you can count all palindromic substrings efficiently in O(n²) time.

Practice

1. What is the main idea behind the two-pointer technique to check if a string is a palindrome?

easy

A. Use two pointers starting from both ends and move towards the center comparing characters

B. Reverse the string and compare it with the original string

C. Count the frequency of each character and check if all are even

D. Sort the string and check if it matches the original

Solution

1. Step 1: Understand the two-pointer approach

   Two pointers start at the beginning and end of the string and move inward.

2. Step 2: Compare characters at pointers

   If characters at both pointers match, move pointers closer; if not, string is not palindrome.

3. Final Answer:

   Use two pointers starting from both ends and move towards the center comparing characters -> Option A

4. Quick Check:

   Two-pointer technique = Use two pointers starting from both ends and move towards the center comparing characters [OK]

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

Common Mistakes:

• Trying to reverse the string instead of using pointers
• Checking only half the string without comparing both ends
• Ignoring case or non-alphanumeric characters

2. Which of the following JavaScript code snippets correctly initializes two pointers for palindrome checking?

easy

A. let left = s.length - 1, right = 0;

B. let left = 1, right = s.length;

C. let left = s.length, right = 0;

D. let left = 0, right = s.length - 1;

Solution

1. Step 1: Identify correct pointer initialization

   Left pointer should start at 0 (start of string), right pointer at last index (length - 1).

2. Step 2: Check each option

   let left = 0, right = s.length - 1; correctly sets left=0 and right=s.length-1; others have incorrect indices.

3. Final Answer:

   let left = 0, right = s.length - 1; -> Option D

4. Quick Check:

   Start pointers at 0 and length-1 = let left = 0, right = s.length - 1; [OK]

Hint: Start left at 0 and right at length minus one [OK]

Common Mistakes:

• Setting right pointer to s.length (out of bounds)
• Swapping left and right pointers
• Starting left pointer at 1 instead of 0

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

function isPalindrome(s) {
  let left = 0, right = s.length - 1;
  while (left < right) {
    if (s[left] !== s[right]) return false;
    left++;
    right--;
  }
  return true;
}
console.log(isPalindrome('racecar'));
console.log(isPalindrome('hello'));

medium

A. true false

B. false true

C. true true

D. false false

Solution

1. Step 1: Trace isPalindrome('racecar')

   Characters match from both ends moving inward, so returns true.

2. Step 2: Trace isPalindrome('hello')

   Characters at start and end differ ('h' vs 'o'), returns false immediately.

3. Final Answer:

   true false -> Option A

4. Quick Check:

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

Hint: Check characters from ends; stop at first mismatch [OK]

Common Mistakes:

• Assuming 'hello' is palindrome
• Not returning false immediately on mismatch
• Confusing return values order

4. Find the error in this palindrome check code:

function isPalindrome(s) {
  let left = 0, right = s.length;
  while (left < right) {
    if (s[left] !== s[right]) return false;
    left++;
    right--;
  }
  return true;
}

medium

A. The while condition should be left <= right

B. Left pointer should start at 1, not 0

C. Right pointer should start at s.length - 1, not s.length

D. The function should return false at the end

Solution

1. Step 1: Check pointer initialization

   Right pointer is set to s.length, which is out of string index range (0 to length-1).

2. Step 2: Correct pointer initialization

   Right pointer should be s.length - 1 to point to last character.

3. Final Answer:

   Right pointer should start at s.length - 1, not s.length -> Option C

4. Quick Check:

   Right pointer = length - 1 [OK]

Hint: Right pointer must be last index (length - 1) [OK]

Common Mistakes:

• Using s.length as index causes undefined access
• Changing left pointer start incorrectly
• Incorrect loop condition causing infinite loop

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 characters case-insensitively

C. Only check the first half of the string

D. Convert the string to uppercase and compare characters directly

Solution

1. Step 1: Understand the input string

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

2. Step 2: Modify two-pointer approach

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

3. Final Answer:

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

4. Quick Check:

   Clean and lowercase string before comparing [OK]

Hint: Skip symbols and compare lowercase letters only [OK]

Common Mistakes:

• Comparing characters without ignoring symbols
• Not handling uppercase vs lowercase differences
• Assuming direct comparison works on raw string