比标准答案快25倍

Question

我有以下内容：

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');

我的代码出了什么问题？我想检查这个词是否是回文。

Answer 1

也许我会建议替代解决方案：

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

UPD。但请记住，这是非常“欺骗”的方法，是语言功能的智能使用的演示，但不是最实用的算法（时间O（n），空间O（n））。对于现实生活应用或编码面试，你一定要使用循环解决方案。 Jason Sebring在这个帖子中发布的one简单而有效（时间O（n），空间O（1））。

Answer 2

比标准答案快25倍

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');

因为它定义了＆＃34;我＆＃34;本身

小提琴：http://jsfiddle.net/namcx0yf/9/

这比下面的标准答案快〜25倍。

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

小提琴：http://jsfiddle.net/t0zfjfab/2/

查看性能结果控制台。

虽然解决方案难以阅读和维护，但我建议您理解它以通过递归和位移来证明非分支，以打动您的下一位面试官。

解释

||和＆amp;＆amp;用于控制流程，如＆＃34;如果＆＃34; ＆＃34;其他＆＃34 ;.如果还剩下||是真的，它只是退出真实。如果||的某些内容是假的它必须继续下去。如果＆amp;＆amp;和如果是＆amp;＆amp;和是的，它必须继续下去。这被视为＆＃34;非分支＆＃34;因为它不需要if-else interupts，而只需要进行评估。

1。使用不需要＆＃34; i＆＃34;被定义为一个参数。分配＆＃34;我＆＃34;如果已定义则为自身，否则初始化为0.始终为false，因此始终评估下一个OR条件。

(i = i || 0) < 0

2. 检查＆＃34; i＆＃34;走了一半，但跳过检查中间奇怪的字符。这里移位的比特就像2除以最低偶数除2的结果。如果是真的那么就假定它已经完成了回文。如果false评估下一个OR条件。

i >= s.length >> 1

3。根据＆＃34; i＆＃34;从开始的char和end char进行比较。最终会成为邻居或中间人的邻居。如果错误退出并假设不是回文。如果为true，则继续执行下一个AND条件。

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

4. 再次调用自身，将原始字符串传递为＆＃34; s＆＃34;。因为＆＃34;我＆＃34;在此时确定，它是预先递增的，以继续检查字符串的位置。返回表示是否为回文的布尔值。

isPalindrome(s,++i)

BUT ...

一个简单的for循环仍然是我想象的答案（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

第一个问题

=是分配 ==是比较

第二个问题，你的逻辑是错误的

palindrom.charAt(palindrom.length)-1

你从charAt中减去一个而不是长度。

第三个问题，它仍然是错误的，因为你没有减少i的长度。

Answer 4

对我有用

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 5

这里的逻辑不太正确，您需要检查每个字母以确定该单词是否是回文。目前，您打印多次。怎么样做：

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");
}

应该打印出它确实是一个回文。

Answer 6

最短代码（31个字符）（ES6）：

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

请记住，短代码不一定是最好的。可读性和效率可能更重要。

Answer 7

至少有三件事：

您正尝试使用=测试是否与用于设置相等。您需要使用==或===进行测试。（如果你没有前者的理由，可能就是后者。）
您在检查每个字符后报告结果。但是在你检查了足够的字符之前，你不知道结果。
您仔细检查每个字符对，因为您实际上只需要检查是否first === last而不是last === first。

Answer 8

更清晰的递归函数：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 9

解决技术测试时最重要的事情是不要使用快捷方式 - 他们希望通过算法来了解您的想法！不是你使用的方法。

这是我提出的一个（我吹了测试后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。我也使用了一种捷径方法String.prototype.charAt(n)，但我觉得这很好，因为每种语言本身都支持这种方法。

Answer 10

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

查找和大写小写。将字符串拆分成数组，我不知道为什么还有几个空格，但我想抓住单个字母。

Answer 11

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建议的更改和修复。

Answer 12

=

palindrom[i] = palindrom.charAt(palindrom.length)-1

==

===

palindrom.charAt(palindrom.length)-1应为palindrom.charAt(palindrom.length - i)

Answer 13

分享我的快速变体，它也支持空格

＆＃13;

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;

＆＃13;

<span id="check" />

＆＃13;

Answer 14

我在上述功能中添加了更多内容，以检查字符串，例如“Go a a salami，我是千层面的猪”。

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

由于

Answer 15

我想知道为什么没人建议：

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 16

我以为我会分享自己的解决方案：

＆＃13;

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');

＆＃13;

希望能帮助别人。

Answer 17

递归方法：

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 18

以上一些短吻是好的，但理解起来并不容易，我建议再说一遍：

sizeof

我比较每个字符，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从右开始，直到它们的索引无效（j）。它也使用任何语言

Answer 19

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 20

根据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 21

使用ES6的另一种解决方案

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

Answer 22

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

  return (original === reversed);
}
`

Answer 23

这个解决方案即使字符串包含非字母数字字符也能正常工作。

Microsoft.OneDrive.Sdk.Item folder = await this.oneDriveClient.Drives[Custodian's id].Items[folder.Children.Id].Request().Expand(expandedValue).GetAsync();

Answer 24

这对我有用。

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 25

以为我会使用Array.prototype.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);

Answer 26

使用递归：

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 27

我在面试网站上发现了这个：

编写一个有效的函数来检查是否有任何排列输入字符串是回文。你可以忽略标点符号，我们只关心关于角色。

玩弄它我想出了这段丑陋的代码：）

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;
}

将它留在这里作为后代。

Answer 28

如何使用简单的旗帜

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 29

（JavaScript）使用regexp，它会检查字母数字回文并忽略空格和标点符号。

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 30

使用for循环遍历字符串字符向前（i）和向后（j）。如果str[i]处的角色在任何时候不等于str[j] - 那么它不是回文。如果我们成功地遍历字符串，那么它就是一个回文。

function isPalindrome(str) {
  var valid = true;

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

  return valid;
}

Answer 31

这可以避免正则表达式同时处理具有空格和大写的字符串......

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 32

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 33

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 34

在这种情况下我使用了三元来向后跟踪索引：

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;
   }
}

Answer 35

<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语句来检查是否相等，如果反转值等于初始变量，你自己就是一个回文。

Answer 36

此版本允许特殊字符（例如“ñ”或“àèìòù”）在其他答案中无法解决该问题：

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

Answer 37

很好的回答。这是另一种方法。

    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 38

您可以尝试以下

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

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

Answer 39

如果您想提高效率和，我建议采用这种方法：

function Palindrome(str, len = str.length, i = 0) {
    if (len < 3) 
        return false;

    while (len--) {
        if (str[i] === str[len])
            i++;
        else
            return false;
    }

    return true;
}

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

Answer 40

回文字母是一个字符串，当同时读取前进和后退的方式是相同的。范例：范例：madam，lol，pop，雷达等

简单逻辑

//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"); 
  }

Answer 41

仅递归索引比较：

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

回文检查可以在没有额外空间和空间复杂度 O(1) 的时间复杂度 O(n/2) 中完成，方法是使用左右索引指针并将它们移向中心。我们不需要创建额外的数组或列表来循环字符串。


/*  
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));

您可以根据字符串为空或字符串为小写的边缘情况轻松修改函数以忽略大写情况。

Palindrome检查Javascript

42 个答案:

比标准答案快25倍

解释

BUT ...

最短代码（31个字符）（ES6）：