Palindrome check in Javascript

Question

I have the following:

function checkPalindrom(palindrom)
{

    for( var i = palindrom.length; i > 0; i-- )
    {
        if( palindrom[i] = palindrom.charAt(palindrom.length)-1 )
        {
            document.write('the word is palindrome.');
        }else{
            document.write('the word is not palindrome!');
        }
    }
}
checkPalindrom('wordthatwillbechecked');

What is wrong with my code? I want to check if the word is a palindrome.

Answer 1

Maybe I will suggest alternative solution:

function checkPalindrom (str) {
  return str == str.split('').reverse().join('');
}

UPD. Keep in mind however that this is pretty much "cheating" approach, a demonstration of smart usage of language features, but not the most practical algorithm (time O(n), space O(n)). For real life application or coding interview you should definitely use loop solution. The one posted by Jason Sebring in this thread is both simple and efficient (time O(n), space O(1)).

Answer 2

25x faster than the standard answer

function isPalindrome(s,i) {
 return (i=i||0)<0||i>=s.length>>1||s[i]==s[s.length-1-i]&&isPalindrome(s,++i);
}

use like:

isPalindrome('racecar');

as it defines "i" itself

Fiddle: http://jsfiddle.net/namcx0yf/9/

This is ~25 times faster than the standard answer below.

function checkPalindrome(str) {
  return str == str.split('').reverse().join('');
}

Fiddle: http://jsfiddle.net/t0zfjfab/2/

View console for performance results.

Although the solution is difficult to read and maintain, I would recommend understanding it to demonstrate non-branching with recursion and bit shifting to impress your next interviewer.

explained

The || and && are used for control flow like "if" "else". If something left of || is true, it just exits with true. If something is false left of || it must continue. If something left of && is false, it exits as false, if something left of a && is true, it must continue. This is considered "non-branching" as it does not need if-else interupts, rather its just evaluated.

1. Used an initializer not requiring "i" to be defined as an argument. Assigns "i" to itself if defined, otherwise initialize to 0. Always is false so next OR condition is always evaluated.

(i = i || 0) < 0

2. Checks if "i" went half way but skips checking middle odd char. Bit shifted here is like division by 2 but to lowest even neighbor division by 2 result. If true then assumes palindrome since its already done. If false evaluates next OR condition.

i >= s.length >> 1

3. Compares from beginning char and end char according to "i" eventually to meet as neighbors or neighbor to middle char. If false exits and assumes NOT palindrome. If true continues on to next AND condition.

s[i] == s[s.length-1-i]

4. Calls itself again for recursion passing the original string as "s". Since "i" is defined for sure at this point, it is pre-incremented to continue checking the string's position. Returns boolean value indicating if palindrome.

isPalindrome(s,++i)

BUT...

A simple for loop is still about twice as fast as my fancy answer (aka KISS principle)

function fastestIsPalindrome(str) {
  var len = Math.floor(str.length / 2);
  for (var i = 0; i < len; i++)
    if (str[i] !== str[str.length - i - 1])
      return false;
  return true;
}

http://jsfiddle.net/6L953awz/1/

Answer 3

The logic here is not quite correct, you need to check every letter to determine if the word is a palindrome. Currently, you print multiple times. What about doing something like:

function checkPalindrome(word) {    
    var l = word.length;
    for (var i = 0; i < l / 2; i++) {
        if (word.charAt(i) !== word.charAt(l - 1 - i)) {
            return false;
        }
    }
    return true;
}

if (checkPalindrome("1122332211")) {
    document.write("The word is a palindrome");
} else {
    document.write("The word is NOT a palindrome");
}

Which should print that it IS indeed a palindrome.

Answer 4

First problem

= is assign == is compare

Second problem, Your logic here is wrong

palindrom.charAt(palindrom.length)-1

You are subtracting one from the charAt and not the length.

Third problem, it still will be wrong since you are not reducing the length by i.

Answer 5

It works to me

function palindrome(str) {
  /* remove special characters, spaces and make lowercase*/
  var removeChar = str.replace(/[^A-Z0-9]/ig, "").toLowerCase();

  /* reverse removeChar for comparison*/
  var checkPalindrome = removeChar.split('').reverse().join('');

  /* Check to see if str is a Palindrome*/
   return (removeChar === checkPalindrome);
}

Answer 6

As a much clearer recursive function: http://jsfiddle.net/dmz2x117/

function isPalindrome(letters) {

    var characters  = letters.split(''),
        firstLetter = characters.shift(),
        lastLetter  = characters.pop();

    if (firstLetter !== lastLetter) {
        return false;
    }

    if (characters.length < 2) {
        return true;
    }

    return isPalindrome(characters.join(''));

}

Answer 7

SHORTEST CODE (31 chars)(ES6):

p=s=>s==[...s].reverse().join``
p('racecar'); //true

Keep in mind short code isn't necessarily the best. Readability and efficiency can matter more.

Answer 8

At least three things:

• You are trying to test for equality with =, which is used for setting. You need to test with == or ===. (Probably the latter, if you don't have a reason for the former.)

• You are reporting results after checking each character. But you don't know the results until you've checked enough characters.

• You double-check each character-pair, as you really only need to check if, say first === last and not also if last === first.

Answer 9

function checkPalindrom(palindrom)
{
   var flag = true;
   var j = 0;
    for( var i = palindrom.length-1; i > palindrom.length / 2; i-- )
    {
        if( palindrom[i] != palindrom[j] )
        {
           flag = false;
           break; // why this? It'll exit the loop at once when there is a mismatch.
        }
        j++;
    }
  if( flag ) {
  document.write('the word is palindrome.');
  }
  else {
document.write('the word is not palindrome.');
  }
}
checkPalindrom('wordthatwillbechecked');

Why am I printing the result outside the loop? Otherwise, for each match in the word, it'll print "is or is not pallindrome" rather than checking the whole word.

EDIT: Updated with changes and a fix suggested by Basemm.

Answer 10

I've added some more to the above functions, to check strings like, "Go hang a salami, I'm a lasagna hog".

function checkPalindrom(str) {
    var str = str.replace(/[^a-zA-Z0-9]+/gi, '').toLowerCase();
    return str == str.split('').reverse().join('');
}

Thanks

Answer 11

The most important thing to do when solving a Technical Test is Don't use shortcut methods -- they want to see how you think algorithmically! Not your use of methods.

Here is one that I came up with (45 minutes after I blew the test). There are a couple optimizations to make though. When writing any algorithm, its best to assume false and alter the logic if its looking to be true.

isPalindrome():

Basically, to make this run in O(N) (linear) complexity you want to have 2 iterators whose vectors point towards each other. Meaning, one iterator that starts at the beginning and one that starts at the end, each traveling inward. You could have the iterators traverse the whole array and use a condition to break/return once they meet in the middle, but it may save some work to only give each iterator a half-length by default.

for loops seem to force the use of more checks, so I used while loops - which I'm less comfortable with.

Here's the code:

/**
 * TODO: If func counts out, let it return 0
 *  * Assume !isPalindrome (invert logic)
 */
function isPalindrome(S){
    var s = S
      , len = s.length
      , mid = len/2;
      , i = 0, j = len-1;

    while(i<mid){
        var l = s.charAt(i);
        while(j>=mid){
            var r = s.charAt(j);
            if(l === r){
                console.log('@while *', i, l, '...', j, r);
                --j;
                break;
            }
            console.log('@while !', i, l, '...', j, r);
            return 0;
        }
        ++i;
    }
    return 1;
}

var nooe = solution('neveroddoreven');  // even char length
var kayak = solution('kayak');  // odd char length
var kayaks = solution('kayaks');

console.log('@isPalindrome', nooe, kayak, kayaks);

Notice that if the loops count out, it returns true. All the logic should be inverted so that it by default returns false. I also used one short cut method String.prototype.charAt(n), but I felt OK with this as every language natively supports this method.

Answer 12

function palindromCheck(str) {
    var palinArr, i,
        palindrom = [],

    palinArr = str.split(/[\s!.?,;:'"-()]/ig);

    for (i = 0; i < palinArr.length; i++) {
        if (palinArr[i].toLowerCase() === palinArr[i].split('').reverse().join('').toLowerCase() &&
            palinArr[i] !== '') {
            palindrom.push(palinArr[i]);
        }
    }
        return palindrom.join(', ');
}
console.log(palindromCheck('There is a man, his name! was Bob.')); //a, Bob

Finds and upper to lower case. Split string into array, I don't know why a few white spaces remain, but I wanted to catch and single letters.

Answer 13

• = in palindrom[i] = palindrom.charAt(palindrom.length)-1 should be == or ===
• palindrom.charAt(palindrom.length)-1 should be palindrom.charAt(palindrom.length - i)

Answer 14

Sharing my fast variant which also support spaces

function isPalindrom(str) {
  var ia = 0;
  var ib = str.length - 1;
  do {
    if (str[ia] === str[ib]) continue;

    // if spaces skip & retry
    if (str[ia] === ' ' && ib++) continue;
    if (str[ib] === ' ' && ia--) continue;

    return false;
  } while (++ia < --ib);
  return true;
}
var palindrom="never odd or even";
var res = isPalindrom(palindrom);
document.getElementById('check').innerHTML ='"'+ palindrom + '"'+" checked to be :" +res;

<span id="check" />

Answer 15

Some above short anwsers is good, but it's not easy for understand, I suggest one more way:

function checkPalindrome(inputString) {

    if(inputString.length == 1){
        return true;
    }else{
        var i = 0;
        var j = inputString.length -1;
        while(i < j){
            if(inputString[i] != inputString[j]){
                return false;
            }
            i++;
            j--;
        }
    }
    return true;
}

I compare each character, i start form left, j start from right, until their index is not valid (i<j). It's also working in any languages

Answer 16

One more solution with ES6

isPalin = str => [...str].every((c, i) => c === str[str.length-1-i]);

Answer 17

You can try the following

function checkPalindrom (str) {
      str = str.toLowerCase();
      return str == str.split('').reverse().join('');
    }

    if(checkPalindrom('Racecar')) {
        console.log('Palindrome');
    } else {
        console.log('Not Palindrome');
    }

Answer 18

function checkPalindrom(palindrom)
{
  palindrom= palindrom.toLowerCase();
   var flag = true;
   var j;
   j = (palindrom.length) -1 ;
   //console.log(j);
   var cnt = j / 2;
   //console.log(cnt);
    for( i = 0; i < cnt+1 ; i++,j-- )
    {
        console.log("J is => "+j);
        console.log(palindrom[i] + "<==>" + palindrom[j]);
        if( palindrom[i] != palindrom[j] )
        {
           flag = false;
           break; 
        }


    }
  if( flag ) {
  console.log('the word is palindrome.');
  }
  else {
console.log('the word is not palindrome.');
  }
}
checkPalindrom('Avid diva');

Answer 19

I'm wondering why nobody suggested this:

ES6:

// "aba" -> true
// "acb" -> false
// "aa" -> true
// "abba" -> true
// "s" -> true
isPalindrom = (str = "") => {
  if (str[0] === str[str.length - 1]) {
    return str.length <= 1 ? true : isPalindrom(str.slice(1, -1))
  }

  return false;
}

alert(["aba", "acb", "aa", "abba", "s"].map((e, i) => isPalindrom(e)).join())

ES5:

// "aba" -> true
// "acb" -> false
// "aa" -> true
// "abba" -> true
// "s" -> true
function isPalindrom(str) => {
  var str = typeof str !== "string" ? "" : str;

  if (str[0] === str[str.length - 1]) {
    return str.length <= 1 ? true : isPalindrom(str.slice(1, -1))
  }

  return false;
}

alert(["aba", "acb", "aa", "abba", "s"].map(function (e, i) {
    return isPalindrom(e);
}).join());

Answer 20

Recursive Method:

var low;
var high;
var A = "abcdcba";  

function palindrome(A , low, high){
  A = A.split('');

 if((low > high) || (low == high)){
   return true;
 }

 if(A[low] === A[high]){
   A = A.join('');
   low = low + 1; 
   high = high - 1; 
   return palindrome(A , low, high);
 }
 else{
   return "not a palindrome";
 }
}

palindrome(A, 0, A.length-1);

Answer 21

I thought I'd share my own solution:

function palindrome(string){
    var reverseString = '';
    for(var k in string){
       reverseString += string[(string.length - k) - 1];
    }
  if(string === reverseString){
    console.log('Hey there palindrome');
  }else{
    console.log('You are not a palindrome');
  }
}
palindrome('ana');

Hope will help someone.

Answer 22

I found this on an interview site:

Write an efficient function that checks whether any permutation of an input string is a palindrome. You can ignore punctuation, we only care about the characters.

Playing around with it I came up with this ugly piece of code :)

function checkIfPalindrome(text) {
    var found = {};
    var foundOne = 0;
    text = text.replace(/[^a-z0-9]/gi, '').toLowerCase();
    for (var i = 0; i < text.length; i++) {
        if (found[text[i]]) {
            found[text[i]]++;
        } else {
            found[text[i]] = 1;
        }
    }
    for (var x in found) {
        if (found[x] === 1) {
            foundOne++;
            if (foundOne > 1) {
                return false;
            }
        }
    }
    for (var x in found) {
        if (found[x] > 2 && found[x] % 2 && foundOne) {
            return false;
        }
    }
    return true;
}

Just leaving it here for posterity.

Answer 23

How about this, using a simple flag

function checkPalindrom(str){
   var flag = true;
   for( var i = 0; i <= str.length-1; i++){
    if( str[i] !== str[str.length - i-1]){
      flag = false;  
     }
    }
    if(flag == false){
      console.log('the word is not a palindrome!');   
    }
    else{
    console.log('the word is a palindrome!');
    }
}

checkPalindrom('abcdcba');

Answer 24

(JavaScript) Using regexp, this checks for alphanumeric palindrome and disregards space and punctuation.

function palindrome(str) {
  str = str.match(/[A-Za-z0-9]/gi).join("").toLowerCase();
  //  (/[A-Za-z0-9]/gi) above makes str alphanumeric

  for(var i = 0; i < Math.floor(str.length/2); i++) { //only need to run for half the string length 
    if(str.charAt(i) !== str.charAt(str.length-i-1)) { // uses !== to compare characters one-by-one from the beginning and end
      return "Try again.";
    }
  }
  return "Palindrome!";
}
palindrome("A man, a plan, a canal. Panama.");
//palindrome("4_2 (: /-\ :) 2-4"); // This solution would also work on something like this.

Answer 25

Loop through the string characters both forwards (i) and backwards (j) using a for loop. If at any point the character at str[i] does not equal str[j] - then it is not a palindrome. If we successfully loop through the string then it is a palindrome.

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

  return true
}

Answer 26

`
function checkPalindrome (str) {
    var str = str.toLowerCase();
    var original = str.split(' ').join('');
    var reversed = original.split(' ').reverse().join('');

  return (original === reversed);
}
`

Answer 27

This avoids regex while also dealing with strings that have spaces and uppercase...

function isPalindrome(str) {
    str = str.split("");

    var str2 = str.filter(function(x){ 
        if(x !== ' ' && x !== ',') {
            return x;
        }
    });

    return console.log(str2.join('').toLowerCase()) == console.log(str2.reverse().join('').toLowerCase());
};

isPalindrome("A car, a man, a maraca"); //true

Answer 28

Using recursion:

function isPalindromeRecursive(str) {
  const isLessThan2 = str.length < 2;
  const firstAndLastEqual = str.slice(0, 1) === str.slice(-1);
  return !isLessThan2 && firstAndLastEqual 
    ? isPalindromeRecursive(str.slice(1, -1)) 
    : isLessThan2;
}

Answer 29

function myPolidrome(polidrome){
 var string=polidrome.split('').join(',');
 for(var i=0;i<string.length;i++){
    if(string.length==1){
     console.log("is polidrome");
   }else if(string[i]!=string.charAt(string.length-1)){
     console.log("is not polidrome");
     break;
  }else{
     return  myPolidrome(polidrome.substring(1,polidrome.length-1));
  }
  }
  }
myPolidrome("asasdsdsa");

Answer 30

Thought I will share my solution using Array.prototype.filter(). filter() filters the array based on boolean values the function returns.

var inputArray=["","a","ab","aba","abab","ababa"]
var outputArray=inputArray.filter(function isPalindrome(x){
  if (x.length<2) return true;
  var y=x.split("").reverse().join("");
  return x==y;
})
console.log(outputArray);

Answer 31

This worked for me.

var number = 8008
number = number + "";
numberreverse = number.split("").reverse().join('');
console.log ("The number if reversed is: " +numberreverse);
if (number == numberreverse)
    console.log("Yes, this is a palindrome");
else
    console.log("Nope! It isnt a palindrome");

Answer 32

Here is a solution that works even if the string contains non-alphanumeric characters.

function isPalindrome(str) {
    str = str.toLowerCase().replace(/\W+|_/g, '');
    return str == str.split('').reverse().join('');
}

Answer 33

Writing the code for checking palindromes following the best practices of JavaScript:

(function(){
 'use strict';
 
 var testStringOne = "Madam";
 var testStringTwo = "testing";
 var testNull = null;
 var testUndefined;
 
 console.log(checkIfPalindrome(testStringOne));
 console.log(checkIfPalindrome(testStringTwo));
 console.log(checkIfPalindrome(testNull));
 console.log(checkIfPalindrome(testUndefined));
 
 function checkIfPalindrome(testStringOne){
  
  if(!testStringOne){
   return false;
  }
  
  var testArrayOne = testStringOne.toLowerCase().split("");
  testArrayOne.reverse();
  
  if(testArrayOne.toString() == testStringOne.toLowerCase().split("").toString()){
   return true;
  }else{
   return false;
  }
 }
 
})();

Answer 34

If you want efficiency and simplicity, I recommend this approach:

function Palindrome(str = '') {
    let len = str.length;
    let i = -1;

    if (len < 3) { 
        return false;
    }
  
    while (len-- > i++) {
        if (str[i] !== str[len]) {
            return false;
        }
    }

    return true;
}

console.log(Palindrome('aba'))//true
console.log(Palindrome('abc'))//false

Answer 35

Some notable logics for Palindrome check

Filter alphaNumeric and make case insensitive

alnum filteration

str = text.toLowerCase().replace(/[^A-Za-z0-9]/g,''); 

non-word chars filteration

str = text.toLowerCase().replace(/[\W_]/g,'');

Palindrome logics

inbuilt methods [shorter]

const isPalindrome = (str) => str === [...str].reverse().join('');

all chars iteration [ simpler ]

const isPalindrome = (str) => {
    let rev = "";
    length = str.length;
    while(length--){
        rev += str[length];
    }
    return str === rev;
}

2 pointer approach [ performance ]

const isPalindrome = (str) => {
    const length = str.length;
    const halfLength = Math.floor(length /2);
    for(let i=0;i<halfLength; i++){
        if(str[i] !== str[length-1-i]){
            return false;
        }
    }
    return true;
}

recursive [eloquent]

const isPalindrome = (str) => {
const length = str.length;
    if (length <= 1){
        return true;
    } else if (str.charAt(0) !== str.slice(-1)){
        return false;
    } else{
        return isPalindrome(str.substring(1,length-1));
    } 
}

// inbuilt methods [shorter]
const isPalindrome1 = (text) => {
  let str = text.toLowerCase().replace(/[^A-Za-z0-9]/g, '')
  return str === [...str].reverse().join('');
}

// native logic [easier]
const isPalindrome2 = (text) => {
  let str = text.toLowerCase().replace(/[^A-Za-z0-9]/g, '')
  let rev = "";
  length = str.length;
  while(length--){
    rev += str[length];
  }
  return str === rev;
}

// 2 pointer approach [performance]
const isPalindrome3 = (text) => {
  let str = text.toLowerCase().replace(/[\W_]/g,'');
  const length = str.length;
  const halfLength = Math.floor(length /2);
  for(let i=0;i<halfLength; i++){
    if(str[i] !== str[length-1-i]){
      return false;
    }
  }
  return  true;
}

// recursive [ eloquent ]
const isPalindrome4 = (text) => {
  let str = text.toLowerCase().replace(/[\W_]/g,'');
  const length = str.length;
  if (length <= 1){
    return true;
  } else if (str.charAt(0) !== str.slice(-1)){
    return false;
  } else{
    return isPalindrome4(str.substring(1,length-1));
  }
}


console.log(isPalindrome1("A man, a plan, a canal. Panama.")); //=> true
console.log(isPalindrome2("madam  # ")) //=> true // only alnum for consideration
console.log(isPalindrome3("table")) //=> false
console.log(isPalindrome4("malayalam")) //=> true

For more ways

Multiple ways to check palindromes

Weird solution to test your skill

Answer 36

I believe this approach is much more readable and straightforward.

Array.from(str).every((char,index)=>char===str[(str.length-(index+1))]);

Answer 37

function palindrome(str) {
// Good luck!
//convert the string into lowerCase.
 str = str.toLowerCase();
//this line remove all non=alphanumeric characters.
 strAlphaNum = str.replace(/[^a-z0-9]/g,"");
//this line create an array of the strAlphaNum string.
 strArray = strAlphaNum.split("");
//this line reverse the array
 strReversed = strArray.reverse();
//this line join the reversed array to make a string whithout space.
 strRevJoin = strReversed.join("");
//this condition check if the given string is a palindrome.
 if (strAlphaNum === strRevJoin){
 return true;}    
 else {return false;}
 }

Answer 38

<script>
    function checkForPally() {
        var input = document.getElementById("inputTable").value;
        var input = input.replace(/\s/g, ''); 
        var arrayInput = input.split(); 
        var inputReversed = arrayInput.reverse();
        var stringInputReversed = inputReversed.join("");

        if (input == stringInputReversed) {
            check.value = "The word you enter is a palindrome"
        }
        if (input != stringInputReversed) {
            check.value = "The word you entered is not a palindrome"
        }
    }
</script>

You first use the getElement tag to set the initial variable of the palindrome. Seeing as a palindrome can be multiple words you use the regex entry to remove the whitespaces. You then use the split function to convert the string into an array.

Next up, you use the reverse method to reverse the array when this is done you join the reversed array back into a string. Lastly, you just use a very basic if statement to check for equality, if the reversed value is equall to the initial variable you have yourself a palindrome.

Answer 39

This version allows special characters like "ñ" or "àèìòù" that in other answers doesn`t resolve it:

function palindromeUnicode(s)
{
     var sc = decodeURIComponent(escape(s));
     return sc === Array.from(sc).reverse().join('')
}
console.log(palindromeUnicode('áñitalavalatiñá')); //true

Answer 40

Nice answers here. Here is another approach.

    function checkPalindrom(palindrom){
      var len = palindrom.length; //get length of the word
      var pos = len-1;      //get index of the last character
      var median  = len/2  // get median character
      if(len <= 1){
         document.write("The word is a Palindrome");
      }else{
         for(var i = 0; i < median+1; i++){
           if(palindrom.charAt(i) == palindrom.charAt(pos-i)){
             document.write("The word is a Palindrome")
           }
         }
         document.write("The word is not a Palindrome")
      }       

      checkPalindrom('wordthatwillbechecked');

Answer 41

recursion only index compare:

const isPalindrome = (str, start = 0, end = str.length - 1) => {
    if (start >= end) {
        return true;
    }

    if (str[start] === str[end]) {
        return isPalindrome(str, start + 1, end - 1);
    }

    return false;
};

Answer 42

A palindrome check can be done in Time Complexity O(n/2) with no Extra Space and Space Complexity O(1), by having left and right index pointers and move them towards the center. We don't need to create an extra array or list to loop through a string.

/*  
Check for planindrome
@string - input
@left - start index of string/input
@right - last index of string/input (which we can get from string.length - 1)
*/

function isPlaindrome(string, left, right) {
    while(left < right) {
        if(string[left] !== string[right]) {
            return false;
        };
        left++;
        right--;
    };

    return true;
};

console.log('abc =>', isPlaindrome('abc', 0, 'abc'.length - 1));
console.log('racecar => ', isPlaindrome('racecar', 0, 'racecar'.length - 1));
console.log('abba => ', isPlaindrome('abba', 0, 'abba'.length - 1));
console.log('xyzzyx => ', isPlaindrome('xyzzyx', 0, 'xyzzyx'.length - 1));

You can easily modify the function based on edge cases for string empty or string to lowercase to ignore caps situation.

Answer 43

The fastest for me using JSON.stringify instead of .join('')

function isPalindrome(s: string): boolean {
  s = s.replace(/[^a-zA-Z0-9]+/g, "").toLowerCase();
  const arrOfChars = s.split("");
  const reversed = [...arrOfChars].reverse();
  return JSON.stringify(reversed) === JSON.stringify(arrOfChars);
}

Answer 44

O(1) space and O(n) speed

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

    return true;
}

Answer 45

Palindrome is a string, which when read in both forward and backward way is same. Example: Example: madam, lol, pop, radar etc.

Simple Logic

//Sample string
  let str1 = "radar";
//breaking into a char array and sort
  let str1Arr = str1.split("").sort();//a,a,d,r,r
  let str2Arr = str1.split("").reverse().sort();//a,a,d,r,r
//now join both string separately and compare, if both are same then it is pelindrome     
  if(str1Arr.join("") == str2Arr.join(""))
  {
       console.log("Palindrome"); 
  }
  else{
       console.log("Not Palindrome"); 
  }