我有以下内容：
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)）。对于现实生活中的应用程序或编码面试，您绝对应该使用循环解决方案。Jason Sebring 在此线程中发布的内容既简单又高效（时间 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');
因为它定义了“我”本身
小提琴：http: //jsfiddle.net/namcx0yf/9/
这比下面的标准答案快约 25 倍。
function checkPalindrome(str) {
return str == str.split('').reverse().join('');
}
小提琴：http: //jsfiddle.net/t0zfjfab/2/
查看控制台以获取性能结果。
尽管该解决方案难以阅读和维护，但我建议您理解它以通过递归和位移来展示非分支，从而给您的下一位面试官留下深刻印象。
|| 和 && 用于控制流，如“if”“else”。如果 || 剩下的东西 是真的，它只是以真退出。如果某些东西是假的 || 它必须继续。如果 && 左边的东西是假的，它会作为假退出，如果 && 的左边是真的，它必须继续。这被认为是“非分支”，因为它不需要 if-else 中断，而只是对其进行评估。
1.使用不需要将“i”定义为参数的初始化程序。如果已定义，则将“i”分配给自身，否则初始化为 0。始终为假，因此始终评估下一个 OR 条件。
(i = i || 0) < 0
2.检查“i”是否走了一半但跳过检查中间奇数字符。此处的位移位类似于除以 2，但结果是最低的偶数邻居除以 2。如果为真，则假定回文，因为它已经完成。如果 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 循环仍然是我喜欢的答案的两倍（又名 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;
}
第一个问题
= 是赋值 == 是比较
第二个问题，你这里的逻辑是错误的
palindrom.charAt(palindrom.length)-1
您从 charAt 中减去一个而不是长度。
第三个问题，它仍然是错误的，因为你没有将长度减少 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
请记住，短代码不一定是最好的。可读性和效率可能更重要。
至少三件事：
您正在尝试测试与 的相等性=，它用于设置。您需要使用==or进行测试===。（可能是后者，如果你没有前者的理由。）
您在检查每个字符后报告结果。但是，直到您检查了足够多的字符，您才知道结果。
您仔细检查每个字符对，因为您实际上只需要检查 if，sayfirst === last而不是 if last === first。
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
查找和从大写到小写。将字符串拆分为数组，我不知道为什么会留下几个空格，但我想捕捉和单个字母。
我在上述函数中添加了更多内容，以检查诸如“去挂意大利腊肠，我是千层面猪”之类的字符串。
function checkPalindrom(str) {
var str = str.replace(/[^a-zA-Z0-9]+/gi, '').toLowerCase();
return str == str.split('').reverse().join('');
}
谢谢
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');
为什么我要在循环外打印结果？否则，对于单词中的每个匹配项，它将打印“is or is or is not pallindrome”，而不是检查整个单词。
编辑：更新了 Basemm 建议的更改和修复。
解决技术测试时最重要的事情是不要使用捷径——他们想看看你在算法上是如何思考的！不是你使用的方法。
这是我想出的一个（在我通过测试后 45 分钟）。不过，还有一些优化需要做。在编写任何算法时，false如果它看起来是，最好假设并更改逻辑true。
isPalindrome()：
基本上，要使其以O(N)（线性）复杂度运行，您需要 2 个迭代器，它们的向量相互指向。意思是，一个从开头开始的迭代器和一个从结尾开始的迭代器，每个迭代器都向内移动。您可以让迭代器遍历整个数组并使用条件 to 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)，但我觉得这没问题，因为每种语言都支持这种方法。
=在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" />您可以尝试以下方法
function checkPalindrom (str) {
str = str.toLowerCase();
return str == str.split('').reverse().join('');
}
if(checkPalindrom('Racecar')) {
console.log('Palindrome');
} else {
console.log('Not Palindrome');
}
上面的一些简短的答案很好，但不容易理解，我建议另一种方法：
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开始，从右开始，直到它们的索引无效（i<j）。它也适用于任何语言
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');
我想我会分享我自己的解决方案：
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');希望能帮助某人。
递归方法：
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);
我想知道为什么没有人建议这个：
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());
ES6 的另一种解决方案
isPalin = str => [...str].every((c, i) => c === str[str.length-1-i]);
(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.
我在一个采访网站上发现了这个：
编写一个有效的函数来检查输入字符串的任何排列是否是回文。你可以忽略标点符号，我们只关心字符。
玩弄它，我想出了这段丑陋的代码:)
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;
}
就留在这里留给后人吧。
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('');
}
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");
遵循 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 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');
以为我会使用 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);
使用 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 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
这对我有用。
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 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 checkPalindrome (str) {
var str = str.toLowerCase();
var original = str.split(' ').join('');
var reversed = original.split(' ').reverse().join('');
return (original === reversed);
}
`
仅递归索引比较：
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;
};
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;}
}
<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 语句来检查是否相等，如果反转的值等于初始变量，您自己就有一个回文。
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更多方式
此版本允许特殊字符，如“ñ”或“àèìòù”，在其他答案中无法解决：
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');
在这种情况下，我使用了一个三元来向后跟踪索引：
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;
}
}
回文检查可以在没有额外空间和空间复杂度 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 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");
}