Palindrome Detection in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if a string is a palindrome by reversing it.

DSA Javascript

function isPalindrome(str) {
  const reversed = str.split('').reverse().join('');
  return str === [1];
}

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

Astr

Breversed

Cstr.split('')

Dstr.reverse()

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing the string with itself instead of the reversed string.

Trying to reverse the string directly without splitting it first.

The reversed string is stored in the variable reversed. To check if the original string is a palindrome, compare str with reversed.

2fill in blank

medium

Complete the code to check palindrome by comparing characters from start and end.

DSA Javascript

function isPalindrome(str) {
  for (let i = 0; i < [1]; i++) {
    if (str[i] !== str[str.length - 1 - i]) {
      return false;
    }
  }
  return true;
}

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

Astr.length / 2

Bstr.length

Cstr.length - 1

Dstr.length / 3

Attempts:

3 left

💡 Hint

Common Mistakes

Checking the entire string length causing unnecessary comparisons.

Using incorrect loop limits leading to index errors.

We only need to check up to half the string length because we compare characters from both ends moving towards the center.

3fill in blank

hard

Fix the error in the code to correctly check palindrome ignoring case.

DSA Javascript

function isPalindrome(str) {
  str = str.toLowerCase();
  for (let i = 0; i < str.length / 2; i++) {
    if (str[i] !== [1]) {
      return false;
    }
  }
  return true;
}

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

Astr[str.length - i]

Bstr[i + 1]

Cstr[str.length - 1 - i]

Dstr[i - 1]

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect index causing out of range errors.

Comparing characters with wrong positions.

To compare characters from both ends, use str[str.length - 1 - i] to get the matching character from the end.

4fill in blank

hard

Fill both blanks to create a function that removes non-alphanumeric characters and checks palindrome.

DSA Javascript

function isPalindrome(str) {
  const cleaned = str.toLowerCase().replace(/[1]/g, '');
  for (let i = 0; i < cleaned.length / 2; i++) {
    if (cleaned[i] !== cleaned[[2]]) {
      return false;
    }
  }
  return true;
}

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

A[^a-z0-9]

B[a-z0-9]

Ccleaned.length - 1 - i

Dcleaned.length - i

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong regex that removes letters or numbers.

Using incorrect index for mirrored character.

The regex [^a-z0-9] removes all characters except letters and numbers. The index cleaned.length - 1 - i accesses the mirrored character from the end.

5fill in blank

hard

Fill all three blanks to create a palindrome check using array methods and filtering.

DSA Javascript

function isPalindrome(str) {
  const filtered = str.toLowerCase().split('').filter(char => /[1]/.test(char));
  const reversed = [...filtered].reverse();
  return filtered.[2]((char, index) => char === reversed[[3]]);
}

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

A[a-z0-9]

Bevery

Cindex

Dsome

Attempts:

3 left

💡 Hint

Common Mistakes

Using some instead of every causing incorrect results.

Using wrong regex that filters out valid characters.

The regex [a-z0-9] filters only letters and numbers. The every method checks if all characters match their reversed counterparts using the index.

Practice

1. What does a palindrome string mean in simple terms?

easy

A. A string that contains only vowels

B. A string that reads the same forwards and backwards

C. A string with all unique characters

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 forwards and backwards, like 'madam' or 'racecar'.

2. Step 2: Compare options with definition

   Only A string that reads the same forwards and backwards matches this definition exactly.

3. Final Answer:

   A string that reads the same forwards and backwards -> Option B

4. Quick Check:

   Palindrome = same forwards and backwards [OK]

Hint: Palindrome means same forwards and backwards [OK]

Common Mistakes:

• Confusing palindrome with unique characters
• Thinking palindrome means only vowels
• Assuming palindrome ends with special character

2. Which of the following JavaScript code snippets correctly checks if a string str is a palindrome?

easy

A. return str === str.split('').reverse().join('');

B. return str === str.toUpperCase();

C. return str.length === 0;

D. return str.indexOf('a') !== -1;

Solution

1. Step 1: Understand palindrome check logic

   To check palindrome, reverse the string and compare with original.

2. Step 2: Analyze code snippets

   return str === str.split('').reverse().join(''); reverses the string and compares it correctly. Others do unrelated checks.

3. Final Answer:

   return str === str.split('').reverse().join(''); -> Option A

4. Quick Check:

   Reverse and compare = return str === str.split('').reverse().join(''); [OK]

Hint: Reverse string and compare to original [OK]

Common Mistakes:

• Using toUpperCase instead of reversing
• Checking string length instead of content
• Searching for a character instead of palindrome

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

function isPalindrome(s) {
  s = s.toLowerCase().replace(/[^a-z0-9]/g, '');
  return s === s.split('').reverse().join('');
}
console.log(isPalindrome('A man, a plan, a canal: Panama'));

medium

A. false

B. undefined

C. SyntaxError

D. true

Solution

1. Step 1: Normalize string by removing non-alphanumeric and lowercasing

   The string becomes 'amanaplanacanalpanama' after cleaning.

2. Step 2: Check if cleaned string equals its reverse

   Reversing 'amanaplanacanalpanama' gives the same string, so returns true.

3. Final Answer:

   true -> Option D

4. Quick Check:

   Clean and compare reversed string = true [OK]

Hint: Ignore case and non-letters, then compare reversed [OK]

Common Mistakes:

• Not removing spaces and punctuation
• Ignoring case differences
• Expecting false due to original formatting

4. Find the error in this palindrome check function:

function checkPalindrome(str) {
  for(let i = 0; i < str.length; i++) {
    if(str[i] !== str[str.length - i]) {
      return false;
    }
  }
  return true;
}

medium

A. Index for comparison should be str.length - i - 1

B. No error, function works correctly

C. Function should convert string to lowercase first

D. Loop should run only till half the string length

Solution

1. Step 1: Analyze index used for comparison

   Index str.length - i is off by one because string indices start at 0.

2. Step 2: Correct index calculation

   It should be str.length - i - 1 to compare correct characters from end.

3. Final Answer:

   Index for comparison should be str.length - i - 1 -> Option A

4. Quick Check:

   Off-by-one index error fixed by subtracting 1 [OK]

Hint: Remember last index is length - 1 [OK]

Common Mistakes:

• Using full length instead of half for loop
• Ignoring off-by-one in index
• Assuming case sensitivity causes error here

5. You want to check if a sentence is a palindrome ignoring spaces, punctuation, and case. Which approach is best to implement in JavaScript?

hard

A. Check if string length is even or odd first

B. Compare original string with reversed string directly

C. Remove non-alphanumeric characters, convert to lowercase, then compare with reversed string

D. Count vowels and consonants and compare counts

Solution

1. Step 1: Understand requirements for ignoring spaces, punctuation, and case

   We must clean the string by removing unwanted characters and normalize case.

2. Step 2: Choose approach that cleans and compares reversed string

   Remove non-alphanumeric characters, convert to lowercase, then compare with reversed string correctly removes non-alphanumeric characters, converts to lowercase, then compares reversed string.

3. Final Answer:

   Remove non-alphanumeric characters, convert to lowercase, then compare with reversed string -> Option C

4. Quick Check:

   Clean and compare reversed string for sentence palindrome [OK]

Hint: Clean string before palindrome check for sentences [OK]

Common Mistakes:

• Comparing raw strings with punctuation
• Ignoring case differences
• Using vowel/consonant counts which is unrelated