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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Two Pointer Palindrome Check

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

DSA Typescript

function isPalindrome(s: string): boolean {
  let left = 0;
  let right = s.length - 1;
  while (left < right) {
    while (left < right && !isAlphaNumeric(s[left])) left++;
    while (left < right && !isAlphaNumeric(s[right])) right--;
    if (s[left].toLowerCase() !== s[right].toLowerCase()) return false;
    left++;
    right--;
  }
  return true;
}

function isAlphaNumeric(c: string): boolean {
  return /^[a-z0-9]$/i.test(c);
}

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

A false

B true

C SyntaxError

D TypeError

💡 Hint

Check how non-alphanumeric characters are skipped and case is ignored.

The code uses two pointers moving inward, skipping non-alphanumeric characters and comparing characters case-insensitively. The input is a classic palindrome phrase ignoring punctuation and spaces, so the function returns true.

❓ Predict Output

intermediate

Result of Palindrome Check on Non-Palindrome String

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

DSA Typescript

function isPalindrome(s: string): boolean {
  let left = 0;
  let right = s.length - 1;
  while (left < right) {
    while (left < right && !isAlphaNumeric(s[left])) left++;
    while (left < right && !isAlphaNumeric(s[right])) right--;
    if (s[left].toLowerCase() !== s[right].toLowerCase()) return false;
    left++;
    right--;
  }
  return true;
}

function isAlphaNumeric(c: string): boolean {
  return /^[a-z0-9]$/i.test(c);
}

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

A SyntaxError

B TypeError

C false

D true

💡 Hint

Check the characters compared after skipping spaces.

The string "race a car" is not a palindrome because the characters 'e' and 'a' do not match when comparing from the ends inward.

🧠 Conceptual

advanced

Why Use Two Pointers for Palindrome Check?

Why is the two-pointer technique efficient for checking if a string is a palindrome ignoring non-alphanumeric characters and case?

A It uses recursion to compare characters, which is more memory efficient.

B It sorts the string first, then compares characters, which is faster than other methods.

C It converts the string to a number and checks if the number is a palindrome.

D It allows checking characters from both ends simultaneously, skipping unwanted characters, reducing time complexity to O(n).

💡 Hint

Think about how the pointers move and what characters they compare.

Two pointers start at the beginning and end of the string and move inward, skipping non-alphanumeric characters and comparing characters case-insensitively. This avoids extra space and checks in one pass.

🔧 Debug

advanced

Identify the Error in Palindrome Function

What error will this TypeScript code produce when checking if "No lemon, no melon" is a palindrome?

DSA Typescript

function isPalindrome(s: string): boolean {
  let left = 0;
  let right = s.length - 1;
  while (left < right) {
    while (left < right && !isAlphaNumeric(s[left])) left++
    while (left < right && !isAlphaNumeric(s[right])) right--
    if (s[left].toLowerCase() !== s[right].toLowerCase()) return false
    left++
    right--
  }
  return true
}

function isAlphaNumeric(c: string): boolean {
  return /^[a-z0-9]$/i.test(c);
}

console.log(isPalindrome("No lemon, no melon"));

A No error, outputs true

B TypeError because toLowerCase is called on undefined

C SyntaxError due to missing semicolons

D Runtime error due to infinite loop

💡 Hint

Check if missing semicolons cause errors in TypeScript.

TypeScript allows optional semicolons; the code runs fine and returns true because the string is a palindrome ignoring punctuation and case.

🚀 Application

expert

Count Palindromic Substrings Using Two Pointers

Given a string, which approach correctly counts all palindromic substrings using the two-pointer technique?

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

B Sort the string and count repeated characters as palindromes.

C Use two pointers only at the start and end of the string once to count palindromes.

D Reverse the string and compare with original to count palindromes.

💡 Hint

Think about how to find palindromes of different lengths centered at each position.

Expanding around each center with two pointers allows counting all palindromic substrings efficiently by checking odd and even length palindromes.

Practice

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

easy

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

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

C. Use two pointers starting at both ends and move towards the center comparing characters

D. Sort the characters and check if the sorted string equals the original

Solution

1. Step 1: Understand 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; otherwise, it's not a palindrome.

3. Final Answer:

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

4. Quick Check:

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

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

Common Mistakes:

• Reversing string instead of using pointers
• Checking only half the string without pointers
• Ignoring case or non-alphanumeric characters

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

easy

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

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

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

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

Solution

1. Step 1: Identify pointer positions

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

2. Step 2: Check code correctness

   let left = 0; let right = s.length - 1; correctly sets left = 0 and right = s.length - 1, valid indices for string.

3. Final Answer:

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

4. Quick Check:

   Pointers start at 0 and length-1 = let left = 0; let 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)
• Starting left pointer at 1 instead of 0
• Confusing length with last index

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

function isPalindrome(s: string): boolean {
  let left = 0;
  let 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 'racecar' input

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

2. Step 2: Trace 'hello' input

   Characters 'h' and 'o' differ at ends, returns false immediately.

3. Final Answer:

   true false -> Option A

4. Quick Check:

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

Hint: Check characters from ends; mismatch means false [OK]

Common Mistakes:

• Assuming 'hello' is palindrome
• Returning true without checking all pairs
• Off-by-one errors in pointer movement

4. Identify the bug in this TypeScript palindrome checker:

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

medium

A. left pointer should start at 1

B. right pointer initialized to s.length instead of s.length - 1

C. Comparison should be s[left] === s[right]

D. Loop condition should be left <= right

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: Understand impact of bug

   Accessing s[s.length] causes undefined comparison or runtime error.

3. Final Answer:

   right pointer initialized to s.length instead of s.length - 1 -> Option B

4. Quick Check:

   Right pointer must be last index = length-1 [OK]

Hint: Right pointer must be last index, not length [OK]

Common Mistakes:

• Using s.length as index causes out-of-bounds
• Changing loop condition incorrectly
• Confusing equality and inequality in comparison

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

hard

A. Convert string to uppercase and compare all characters

B. Reverse the string and compare directly

C. Only compare characters at even indices

D. Ignore case and skip non-alphanumeric characters during comparison

Solution

1. Step 1: Understand input complexity

   String contains spaces, commas, and mixed case letters which must be ignored for palindrome check.

2. Step 2: Modify two-pointer logic

   Skip non-alphanumeric characters and compare characters case-insensitively while moving pointers inward.

3. Final Answer:

   Ignore case and skip non-alphanumeric characters during comparison -> Option D

4. Quick Check:

   Skip non-letters and ignore case for valid palindrome [OK]

Hint: Skip non-letters and compare lowercase chars [OK]

Common Mistakes:

• Comparing characters without ignoring punctuation
• Not converting characters to same case
• Assuming direct comparison works on raw string