私は次のものを持っています：
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');
私のコードの何が問題になっていますか？その単語が回文であるかどうかを確認したいと思います。
多分私は別の解決策を提案します：
function checkPalindrom (str) {
return str == str.split('').reverse().join('');
}
UPD。ただし、これはほとんど「不正行為」アプローチであり、言語機能のスマートな使用法のデモンストレーションですが、最も実用的なアルゴリズム（時間O（n）、空間O（n））ではないことに注意してください。実際のアプリケーションやコーディングインタビューでは、必ずループソリューションを使用する必要があります。このスレッドでJasonSebringによって投稿されたものは、単純で効率的です（時間O（n）、スペースO（1））。
function isPalindrome(s,i) {
return (i=i||0)<0||i>=s.length>>1||s[i]==s[s.length-1-i]&&isPalindrome(s,++i);
}
次のように使用します：
isPalindrome('racecar');
「i」自体を定義するので
フィドル： http： //jsfiddle.net/namcx0yf/9/
これは、以下の標準的な回答よりも約25倍高速です。
function checkPalindrome(str) {
return str == str.split('').reverse().join('');
}
フィドル： http： //jsfiddle.net/t0zfjfab/2/
パフォーマンス結果については、コンソールを表示してください。
ソリューションを読んで維持するのは難しいですが、次のインタビュアーを感動させるために、再帰とビットシフトを伴う非分岐を示すためにそれを理解することをお勧めします。
|| および&&は、「if」、「else」などの制御フローに使用されます。何かが残っている場合|| trueの場合、trueで終了します。||の左側に何かが間違っている場合 継続する必要があります。&&の左側にあるものがfalseの場合、falseとして終了します。&&の左側にあるものがtrueの場合、続行する必要があります。これは、if-elseの割り込みを必要とせず、評価されたばかりであるため、「非分岐」と見なされます。
1.引数として「i」を定義する必要のない初期化子を使用しました。定義されている場合はそれ自体に「i」を割り当て、そうでない場合は0に初期化します。常にfalseであるため、次のOR条件が常に評価されます。
(i = i || 0) < 0
2.「i」が途中まで進んだかどうかをチェックしますが、真ん中の奇数文字のチェックをスキップします。ここでビットシフトされたのは2による除算のようなものですが、結果として隣接する除算でさえ最低になります。trueの場合、すでに実行されているため、回文を想定します。falseの場合、次のOR条件を評価します。
i >= s.length >> 1
3.「i」に従って最初の文字と最後の文字を比較して、最終的には隣人または中間の文字の隣人として会います。falseが終了し、回文ではないと想定した場合。trueの場合、次のAND条件に進みます。
s[i] == s[s.length-1-i]
4.元の文字列を「s」として渡す再帰のために自分自身を再度呼び出します。この時点で「i」は確実に定義されているため、文字列の位置をチェックし続けるために事前にインクリメントされます。回文かどうかを示すブール値を返します。
isPalindrome(s,++i)
単純なforループは、私の空想的な答えの約2倍の速さです（別名KISSの原則）
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;
}
最初の問題
=割り当てます==比較します
2番目の問題、ここでのあなたの論理は間違っています
palindrom.charAt(palindrom.length)-1
長さではなく、charAtから1を引いています。
3番目の問題は、長さをiだけ短縮していないため、それでも間違いです。
ここでの論理は完全には正しくありません。すべての文字をチェックして、その単語が回文であるかどうかを判断する必要があります。現在、複数回印刷しています。次のようなことはどうですか？
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");
}
それが確かに回文であることを印刷する必要があります。
それは私に働きます
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);
}
より明確な再帰関数として：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(''));
}
p=s=>s==[...s].reverse().join``
p('racecar'); //true
ショートコードが必ずしも最良であるとは限らないことに注意してください。読みやすさと効率はもっと重要です。
少なくとも3つのこと：
設定に使用される、との同等性をテストしようとして=います。==またはでテストする必要があります===。（前者の理由がない場合は、おそらく後者です。）
各キャラクターをチェックした後、結果を報告しています。しかし、十分な数の文字をチェックするまで、結果はわかりません。
実際には、言うかどうかだけを確認する必要があり、そうfirst === lastでない場合も確認する必要があるため、各文字ペアを再確認しますlast === first。
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');
ループの外側に結果を出力するのはなぜですか？それ以外の場合は、単語内の一致ごとに、単語全体をチェックするのではなく、「pallindromeであるかどうか」と出力されます。
編集：Basemmによって提案された変更と修正で更新されました。
上記の関数にさらにいくつか追加して、「サラミを吊るしてください、私はラザニアの豚です」のような文字列をチェックします。
function checkPalindrom(str) {
var str = str.replace(/[^a-zA-Z0-9]+/gi, '').toLowerCase();
return str == str.split('').reverse().join('');
}
ありがとう
テクニカルテストを解くときに行うべき最も重要なことは、ショートカットメソッドを使用しないことです-彼らはあなたがアルゴリズム的にどのように考えるかを見たいと思っています！メソッドの使用ではありません。
これが私が思いついたものです（テストを吹き飛ばしてから45分後）。ただし、いくつかの最適化を行う必要があります。アルゴリズムを作成するときfalseは、ロジックを想定して変更するのが最善trueです。
isPalindrome()：
基本的に、これをO（N） （線形）の複雑さで実行するには、ベクトルが互いに向き合う2つのイテレーターが必要です。つまり、最初から開始するイテレータと最後から開始するイテレータがそれぞれ内側に移動します。イテレータに配列全体をトラバースさせ、条件を使用してbreak/イテレータが中央で出会うようにすることもできますが、デフォルトで各イテレータに半分の長returnさしか与えないようにすることで、作業を節約できます。
forループはより多くのチェックの使用を強制するように思われるので、私はwhileループを使用しました-私はあまり快適ではありません。
コードは次のとおりです。
/**
* 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);
ループがカウントアウトされると、が返されることに注意してくださいtrue。デフォルトでを返すように、すべてのロジックを反転する必要がありますfalse。私も1つのショートカット方法を使用String.prototype.charAt(n)しましたが、すべての言語がこの方法をネイティブにサポートしているので、これで問題ないと感じました。
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
検索と大文字から小文字。文字列を配列に分割します。なぜ空白がいくつか残っているのかわかりませんが、1文字をキャッチしたかったのです。
=またはでpalindrom[i] = palindrom.charAt(palindrom.length)-1ある必要があります=====palindrom.charAt(palindrom.length)-1する必要がありますpalindrom.charAt(palindrom.length - i)スペースもサポートする私の高速バリアントを共有する
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" />上記の短い回答のいくつかは良いですが、理解するのは簡単ではありません。もう1つの方法をお勧めします。
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フォームを左から開始し、右から開始します（ ）。また、どの言語でも機能しますji<j
あなたは以下を試すことができます
function checkPalindrom (str) {
str = str.toLowerCase();
return str == str.split('').reverse().join('');
}
if(checkPalindrom('Racecar')) {
console.log('Palindrome');
} else {
console.log('Not Palindrome');
}
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');
なぜ誰もこれを提案しなかったのだろうか：
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());
再帰的方法：
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);
私は自分の解決策を共有したいと思いました：
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');誰かを助けてくれることを願っています。
ES6を使用したもう1つのソリューション
isPalin = str => [...str].every((c, i) => c === str[str.length-1-i]);
私はこれをインタビューサイトで見つけました：
入力文字列の順列が回文であるかどうかをチェックする効率的な関数を記述します。句読点は無視してかまいません。文字のみを考慮します。
それをいじって、私はこの醜いコードを思いついた:)
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;
}
後世のためにここに置いておきます。
簡単な旗を使って、これはどうですか
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');
（JavaScript）正規表現を使用して、英数字の回文をチェックし、スペースと句読点を無視します。
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.
forループを使用して、文字列文字を順方向（i）と逆方向（j）の両方でループします。いずれかの時点での文字が等しくstr[i]ない場合、それは回文ではありません。str[j]文字列を正常にループする場合、それは回文です。
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
}
`
function checkPalindrome (str) {
var str = str.toLowerCase();
var original = str.split(' ').join('');
var reversed = original.split(' ').reverse().join('');
return (original === reversed);
}
`
これにより、スペースと大文字を含む文字列を処理しながら、正規表現を回避できます。
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
再帰の使用：
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;
}
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");
Array.prototype.filter（）を使用してソリューションを共有すると思いました。filter（）は、関数が返すブール値に基づいて配列をフィルタリングします。
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);
これは私のために働いた。
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");
文字列に英数字以外の文字が含まれている場合でも機能するソリューションを次に示します。
function isPalindrome(str) {
str = str.toLowerCase().replace(/\W+|_/g, '');
return str == str.split('').reverse().join('');
}
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;
}
}
})();効率とシンプルさが必要な場合は、次のアプローチをお勧めします。
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
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;}
}
この場合、インデックスを逆方向に追跡するために3項を使用しました。
function palindromeCheck(string) {
let str = string.toLowerCase();
let palindrome;
for (let i = 0; i < str.length; i++) {
if (str[i] === str[str.length - (i == 0 ? 1 : i + 1)]) {
palindrome = true;
} else {
palindrome = false;
}
}
<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>
最初にgetElementタグを使用して、パリンドロームの初期変数を設定します。回文として表示されるのは複数の単語である可能性があり、正規表現エントリを使用して空白を削除します。次に、split関数を使用して、文字列を配列に変換します。
次に、reverseメソッドを使用して配列を反転します。これが完了したら、反転した配列を結合して文字列に戻します。最後に、非常に基本的なifステートメントを使用して等しいかどうかをチェックします。逆の値が初期変数と等しい場合は、回文があります。
このバージョンでは、「ñ」や「àèìòù」など、他の回答では解決されない特殊文字を使用できます。
function palindromeUnicode(s)
{
var sc = decodeURIComponent(escape(s));
return sc === Array.from(sc).reverse().join('')
}
console.log(palindromeUnicode('áñitalavalatiñá')); //true
ここでいい答えがあります。これが別のアプローチです。
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');
再帰のみのインデックス比較：
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;
};
回文チェックは、時間計算量O（n / 2）で、余分なスペースとスペースの複雑さO（1）を使用せずに、左右のインデックスポインターを使用して、それらを中央に向かって移動することで実行できます。文字列をループするために余分な配列やリストを作成する必要はありません。
/*
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));
文字列が空の場合のエッジケースに基づいて関数を簡単に変更したり、文字列を小文字に変更してキャップの状況を無視したりできます。
str = text.toLowerCase().replace(/[^A-Za-z0-9]/g,'');
str = text.toLowerCase().replace(/[\W_]/g,'');
const isPalindrome = (str) => str === [...str].reverse().join('');
const isPalindrome = (str) => {
let rev = "";
length = str.length;
while(length--){
rev += str[length];
}
return str === rev;
}
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;
}
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その他の方法について
回文は文字列であり、順方向と逆方向の両方で読み取った場合は同じです。例：例：マダム、笑、ポップ、レーダーなど。
シンプルなロジック
//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");
}