定义：
回文是单词，短语，数字或其他单位序列，具有在任一方向读取相同属性的属性
如何检查给定的字符串是否是回文？
这是FAIQ [常见问题访谈问题]前一段时间，但主要是使用C语言。
寻找任何和所有语言的解决方案。
答案 0 :(得分：46)
PHP示例：
$string = "A man, a plan, a canal, Panama";
function is_palindrome($string)
{
$a = strtolower(preg_replace("/[^A-Za-z0-9]/","",$string));
return $a==strrev($a);
}
删除任何非字母数字字符（空格，逗号，感叹号等）以允许上述完整句子以及简单的单词。
答案 1 :(得分：34)
Windows XP（可能也适用于2000）或更高版本的BATCH脚本：
@echo off
call :is_palindrome %1
if %ERRORLEVEL% == 0 (
echo %1 is a palindrome
) else (
echo %1 is NOT a palindrome
)
exit /B 0
:is_palindrome
set word=%~1
set reverse=
call :reverse_chars "%word%"
set return=1
if "$%word%" == "$%reverse%" (
set return=0
)
exit /B %return%
:reverse_chars
set chars=%~1
set reverse=%chars:~0,1%%reverse%
set chars=%chars:~1%
if "$%chars%" == "$" (
exit /B 0
) else (
call :reverse_chars "%chars%"
)
exit /B 0
答案 2 :(得分：29)
语言不可知的元代码然后......
rev = StringReverse(originalString)
return ( rev == originalString );
答案 3 :(得分：24)
C＃就地算法。在传递给此函数之前，应该进行任何预处理，例如不区分大小写或删除空格和标点符号。
boolean IsPalindrome(string s) {
for (int i = 0; i < s.Length / 2; i++)
{
if (s[i] != s[s.Length - 1 - i]) return false;
}
return true;
}
编辑：在循环条件中删除了不必要的“+1”，并在删除冗余长度比较时花费了已保存的比较。感谢评论者！
答案 4 :(得分：15)
C＃：LINQ
var str = "a b a";
var test = Enumerable.SequenceEqual(str.ToCharArray(),
str.ToCharArray().Reverse());
答案 5 :(得分：14)
更加Ruby风格的Hal's Ruby version重写：
class String
def palindrome?
(test = gsub(/[^A-Za-z]/, '').downcase) == test.reverse
end
end
现在你可以在任何字符串上调用palindrome?。
答案 6 :(得分：11)
未经优化的Python：
>>> def is_palindrome(s):
... return s == s[::-1]
答案 7 :(得分：11)
Java解决方案：
public class QuickTest {
public static void main(String[] args) {
check("AmanaplanacanalPanama".toLowerCase());
check("Hello World".toLowerCase());
}
public static void check(String aString) {
System.out.print(aString + ": ");
char[] chars = aString.toCharArray();
for (int i = 0, j = (chars.length - 1); i < (chars.length / 2); i++, j--) {
if (chars[i] != chars[j]) {
System.out.println("Not a palindrome!");
return;
}
}
System.out.println("Found a palindrome!");
}
}
答案 8 :(得分：10)
使用良好的数据结构通常会给教授留下深刻的印象：
将一半的字符推到堆栈上（长度/ 2） 弹出并比较每个字符，直到第一个不匹配 如果堆栈元素为零：回文结构 *如果字符串具有奇数长度，则抛出中间字符。
答案 9 :(得分：10)
bool IsPalindrome(char *s)
{
int i,d;
int length = strlen(s);
char cf, cb;
for(i=0, d=length-1 ; i < length && d >= 0 ; i++ , d--)
{
while(cf= toupper(s[i]), (cf < 'A' || cf >'Z') && i < length-1)i++;
while(cb= toupper(s[d]), (cb < 'A' || cb >'Z') && d > 0 )d--;
if(cf != cb && cf >= 'A' && cf <= 'Z' && cb >= 'A' && cb <='Z')
return false;
}
return true;
}
对于“赛车”，“赛车”，“赛车”，“赛车”和“RaCe cAr”，这将是真实的。修改包含符号或空格也很容易，但我认为仅计算字母（并忽略大小写）更有用。这适用于我在答案中找到的所有回文，我一直无法将其欺骗为假阴性/阳性。
另外，如果你不喜欢“C”程序中的bool，它显然可以返回int，返回1并分别返回0表示true和false。
答案 10 :(得分：8)
这是一种蟒蛇方式。注意：这不是真正的“pythonic”，但它演示了算法。
def IsPalindromeString(n):
myLen = len(n)
i = 0
while i <= myLen/2:
if n[i] != n[myLen-1-i]:
return False
i += 1
return True
答案 11 :(得分：6)
Delphi
function IsPalindrome(const s: string): boolean;
var
i, j: integer;
begin
Result := false;
j := Length(s);
for i := 1 to Length(s) div 2 do begin
if s[i] <> s[j] then
Exit;
Dec(j);
end;
Result := true;
end;
答案 12 :(得分：6)
编辑：来自评论：
bool palindrome(std::string const& s)
{
return std::equal(s.begin(), s.end(), s.rbegin());
}
c ++方式。
使用优雅的迭代器我的天真实现。实际上，你可能会检查 一旦你的前向迭代器超过了你的弦的中间标记就停止。
#include <string>
#include <iostream>
using namespace std;
bool palindrome(string foo)
{
string::iterator front;
string::reverse_iterator back;
bool is_palindrome = true;
for(front = foo.begin(), back = foo.rbegin();
is_palindrome && front!= foo.end() && back != foo.rend();
++front, ++back
)
{
if(*front != *back)
is_palindrome = false;
}
return is_palindrome;
}
int main()
{
string a = "hi there", b = "laval";
cout << "String a: \"" << a << "\" is " << ((palindrome(a))? "" : "not ") << "a palindrome." <<endl;
cout << "String b: \"" << b << "\" is " << ((palindrome(b))? "" : "not ") << "a palindrome." <<endl;
}
答案 13 :(得分：6)
我在这里看到了很多不正确的答案。任何正确的解决方案都需要忽略空格和标点符号（实际上是任何非字母字符），并且需要不区分大小写。
一些很好的示例测试用例是：
“一个人，一个计划，一条运河，巴拿马。”
“丰田是丰田。”
“A”
“”
以及一些非回文。
C＃中的示例解决方案（注意：在此设计中，空字符串和空字符串被视为回文，如果不希望这样，则很容易更改）：
public static bool IsPalindrome(string palindromeCandidate)
{
if (string.IsNullOrEmpty(palindromeCandidate))
{
return true;
}
Regex nonAlphaChars = new Regex("[^a-z0-9]");
string alphaOnlyCandidate = nonAlphaChars.Replace(palindromeCandidate.ToLower(), "");
if (string.IsNullOrEmpty(alphaOnlyCandidate))
{
return true;
}
int leftIndex = 0;
int rightIndex = alphaOnlyCandidate.Length - 1;
while (rightIndex > leftIndex)
{
if (alphaOnlyCandidate[leftIndex] != alphaOnlyCandidate[rightIndex])
{
return false;
}
leftIndex++;
rightIndex--;
}
return true;
}
答案 14 :(得分：4)
boolean isPalindrome(String str1) {
//first strip out punctuation and spaces
String stripped = str1.replaceAll("[^a-zA-Z0-9]", "");
return stripped.equalsIgnoreCase((new StringBuilder(stripped)).reverse().toString());
}
Java版
答案 15 :(得分：3)
std::string a = "god";
std::string b = "lol";
std::cout << (std::string(a.rbegin(), a.rend()) == a) << " "
<< (std::string(b.rbegin(), b.rend()) == b);
function ispalin { [ "$( echo -n $1 | tac -rs . )" = "$1" ]; }
echo "$(ispalin god && echo yes || echo no), $(ispalin lol && echo yes || echo no)"
/* obvious solution */
function ispalin(cand, i) {
for(i=0; i<length(cand)/2; i++)
if(substr(cand, length(cand)-i, 1) != substr(cand, i+1, 1))
return 0;
return 1;
}
/* not so obvious solution. cough cough */
{
orig = $0;
while($0) {
stuff = stuff gensub(/^.*(.)$/, "\\1", 1);
$0 = gensub(/^(.*).$/, "\\1", 1);
}
print (stuff == orig);
}
在Haskell中做一些脑死亡的方法
ispalin :: [Char] -> Bool
ispalin a = a == (let xi (y:my) = (xi my) ++ [y]; xi [] = [] in \x -> xi x) a
"Just reverse the string and if it is the same as before, it's a palindrome"
答案 16 :(得分：3)
混淆的C版本：
int IsPalindrome (char *s)
{
char*a,*b,c=0;
for(a=b=s;a<=b;c=(c?c==1?c=(*a&~32)-65>25u?*++a,1:2:c==2?(*--b&~32)-65<26u?3:2:c==3?(*b-65&~32)-(*a-65&~32)?*(b=s=0,a),4:*++a,1:0:*++b?0:1));
return s!=0;
}
答案 17 :(得分：3)
class String
def is_palindrome?
letters_only = gsub(/\W/,'').downcase
letters_only == letters_only.reverse
end
end
puts 'abc'.is_palindrome? # => false
puts 'aba'.is_palindrome? # => true
puts "Madam, I'm Adam.".is_palindrome? # => true
答案 18 :(得分：3)
这是我在c＃
中的解决方案static bool isPalindrome(string s)
{
string allowedChars = "abcdefghijklmnopqrstuvwxyz"+
"1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string compareString = String.Empty;
string rev = string.Empty;
for (int i = 0; i <= s.Length - 1; i++)
{
char c = s[i];
if (allowedChars.IndexOf(c) > -1)
{
compareString += c;
}
}
for (int i = compareString.Length - 1; i >= 0; i--)
{
char c = compareString[i];
rev += c;
}
return rev.Equals(compareString,
StringComparison.CurrentCultureIgnoreCase);
}
答案 19 :(得分：3)
这是一个处理不同情况，标点符号和空格的Python版本。
import string
def is_palindrome(palindrome):
letters = palindrome.translate(string.maketrans("",""),
string.whitespace + string.punctuation).lower()
return letters == letters[::-1]
修改：无耻地从Blair Conrad's neater answer中偷走了我之前版本中稍微笨拙的列表处理。
答案 20 :(得分：3)
这是我的解决方案，不使用strrev。用C＃编写，但它可以在任何具有字符串长度功能的语言中使用。
private static bool Pal(string s) {
for (int i = 0; i < s.Length; i++) {
if (s[i] != s[s.Length - 1 - i]) {
return false;
}
}
return true;
}
答案 21 :(得分：2)
Smalltalk中的三个版本，从最笨到正确。
在Smalltalk中，=是比较运算符：
isPalindrome: aString
"Dumbest."
^ aString reverse = aString
消息#translateToLowercase将字符串返回为小写：
isPalindrome: aString
"Case insensitive"
|lowercase|
lowercase := aString translateToLowercase.
^ lowercase reverse = lowercase
在Smalltalk中，字符串是Collection框架的一部分，您可以使用消息#select:thenCollect:，所以这是最后一个版本：
isPalindrome: aString
"Case insensitive and keeping only alphabetic chars
(blanks & punctuation insensitive)."
|lowercaseLetters|
lowercaseLetters := aString
select: [:char | char isAlphabetic]
thenCollect: [:char | char asLowercase].
^ lowercaseLetters reverse = lowercaseLetters
答案 22 :(得分：2)
一个简单的Java解决方案：
public boolean isPalindrome(String testString) {
StringBuffer sb = new StringBuffer(testString);
String reverseString = sb.reverse().toString();
if(testString.equalsIgnoreCase(reverseString)) {
return true;
else {
return false;
}
}
答案 23 :(得分：2)
请注意，在上述C ++解决方案中，存在一些问题。
一种解决方案效率低下，因为它通过副本传递std :: string，并且因为它遍历所有字符，而不是只比较一半字符。然后，即使发现字符串不是回文，它继续循环，在报告“假”之前等待其结束。
另一个更好，功能非常小，问题是它无法测试除std :: string之外的任何东西。在C ++中，很容易将算法扩展到一大堆类似的对象。通过将其std :: string模板化为“T”，它可以同时用于std :: string，std :: wstring，std :: vector和std :: deque。但是由于使用了运算符＆lt;而没有进行重大修改，std :: list超出了它的范围。
我自己的解决方案试图证明C ++解决方案不会停止处理确切的当前类型，但会努力工作任何行为方式相同，无论类型如何。例如，我可以在std :: string，int的向量或“Anything”列表上应用我的回文测试，只要Anything通过其operator =（类型和类的构建）可比较。
请注意，甚至可以使用可用于比较数据的可选类型扩展模板。例如，如果您想以不区分大小写的方式进行比较，或者甚至比较相似的字符（例如è，é，ë，ê和e）。
像国王列奥尼达斯一样会说：“模板？这是C ++ !!!”所以，在C ++中，至少有3种主要方法可以做到这一点，每种方法都会导致另一种：
问题是，在C ++ 0X之前，我们不能将字符串的std :: string数组视为连续的，因此我们必须“作弊”并检索c_str（）属性。因为我们以只读方式使用它，它应该没问题......
bool isPalindromeA(const std::string & p_strText)
{
if(p_strText.length() < 2) return true ;
const char * pStart = p_strText.c_str() ;
const char * pEnd = pStart + p_strText.length() - 1 ;
for(; pStart < pEnd; ++pStart, --pEnd)
{
if(*pStart != *pEnd)
{
return false ;
}
}
return true ;
}
现在，我们将尝试应用相同的解决方案，但是可以通过operator []随机访问其项目的任何C ++容器。例如，任何std :: basic_string，std :: vector，std :: deque等，Operator []是对这些容器的持续访问，因此我们不会失去过快的速度。
template <typename T>
bool isPalindromeB(const T & p_aText)
{
if(p_aText.empty()) return true ;
typename T::size_type iStart = 0 ;
typename T::size_type iEnd = p_aText.size() - 1 ;
for(; iStart < iEnd; ++iStart, --iEnd)
{
if(p_aText[iStart] != p_aText[iEnd])
{
return false ;
}
}
return true ;
}
它几乎适用于任何带有双向迭代器的无序STL类容器 例如，任何std :: basic_string，std :: vector，std :: deque，std :: list等。 因此，此功能可应用于所有类似STL的容器，具有以下条件： 1 - T是具有双向迭代器的容器 2 - T的迭代器指向可比类型（通过operator =）
template <typename T>
bool isPalindromeC(const T & p_aText)
{
if(p_aText.empty()) return true ;
typename T::const_iterator pStart = p_aText.begin() ;
typename T::const_iterator pEnd = p_aText.end() ;
--pEnd ;
while(true)
{
if(*pStart != *pEnd)
{
return false ;
}
if((pStart == pEnd) || (++pStart == pEnd))
{
return true ;
}
--pEnd ;
}
}
答案 24 :(得分：2)
<强> Lisp的：
(defun palindrome(x) (string= x (reverse x)))
答案 25 :(得分：2)
另一个C ++版本。针对速度和尺寸进行了优化。
bool is_palindrome(const std::string& candidate) {
for(std::string::const_iterator left = candidate.begin(), right = candidate.end(); left < --right ; ++left)
if (*left != *right)
return false;
return true;
}
答案 26 :(得分：2)
此Java代码应在布尔方法中使用：
注意：您只需要检查后半部分字符的前半部分，否则您需要重叠并加倍需要进行的检查。
private static boolean doPal(String test) {
for(int i = 0; i < test.length() / 2; i++) {
if(test.charAt(i) != test.charAt(test.length() - 1 - i)) {
return false;
}
}
return true;
}
答案 27 :(得分：1)
使用Java，使用Apache Commons String Utils：
public boolean isPalindrome(String phrase) {
phrase = phrase.toLowerCase().replaceAll("[^a-z]", "");
return StringUtils.reverse(phrase).equals(phrase);
}
答案 28 :(得分：1)
<强>的Prolog
palindrome(B, R) :-
palindrome(B, R, []).
palindrome([], R, R).
palindrome([X|B], [X|R], T) :-
palindrome(B, R, [X|T]).
答案 29 :(得分：1)
我的2c。每次都避免全字符串反转的开销，一旦确定了字符串的性质，就利用短路来返回。是的，你应该首先调整你的字符串，但IMO是另一个函数的工作。
在C＃
/// <summary>
/// Tests if a string is a palindrome
/// </summary>
public static bool IsPalindrome(this String str)
{
if (str.Length == 0) return false;
int index = 0;
while (index < str.Length / 2)
if (str[index] != str[str.Length - ++index]) return false;
return true;
}
答案 30 :(得分：1)
Erlang很棒
palindrome(L) -> palindrome(L,[]).
palindrome([],_) -> false;
palindrome([_|[]],[]) -> true;
palindrome([_|L],L) -> true;
palindrome(L,L) -> true;
palindrome([H|T], Acc) -> palindrome(T, [H|Acc]).
答案 31 :(得分：1)
还没有使用JavaScript的解决方案吗？
function palindrome(s) {
var l = 0, r = s.length - 1;
while (l < r) if (s.charAt(left++) !== s.charAt(r--)) return false;
return true
}
答案 32 :(得分：1)
有很多方法可以做到这一点。我想关键是尽可能以最有效的方式完成（没有循环字符串）。我会把它作为一个char数组，可以很容易地反转（使用C＃）。
string mystring = "abracadabra";
char[] str = mystring.ToCharArray();
Array.Reverse(str);
string revstring = new string(str);
if (mystring.equals(revstring))
{
Console.WriteLine("String is a Palindrome");
}
答案 33 :(得分：1)
C ++：
bool is_palindrome(const string &s)
{
return equal( s.begin(), s.begin()+s.length()/2, s.rbegin());
}
答案 34 :(得分：1)
在Ruby中，转换为小写并剥离所有不是字母的：
def isPalindrome( string )
( test = string.downcase.gsub( /[^a-z]/, '' ) ) == test.reverse
end
但那感觉就像是作弊，对吗？没有指针或任何东西！所以这里也是一个C版本，但没有小写和字符剥离的好处：
#include <stdio.h>
int isPalindrome( char * string )
{
char * i = string;
char * p = string;
while ( *++i ); while ( i > p && *p++ == *--i );
return i <= p && *i++ == *--p;
}
int main( int argc, char **argv )
{
if ( argc != 2 )
{
fprintf( stderr, "Usage: %s <word>\n", argv[0] );
return -1;
}
fprintf( stdout, "%s\n", isPalindrome( argv[1] ) ? "yes" : "no" );
return 0;
}
嗯，这很有趣 - 我能得到这份工作吗; ^）
答案 35 :(得分：1)
的Python：
if s == s[::-1]: return True
爪哇：
if (s.Equals(s.Reverse())) { return true; }
PHP：
if (s == strrev(s)) return true;
的Perl：
if (s == reverse(s)) { return true; }
二郎：
string:equal(S, lists:reverse(S)).
答案 36 :(得分：1)
的Perl：
sub is_palindrome($)
{
$s = lc(shift); # ignore case
$s =~ s/\W+//g; # consider only letters, digits, and '_'
$s eq reverse $s;
}
忽略大小写并删除非字母数字字符（区域设置和unicode-中性）。
答案 37 :(得分：1)
简单的 JavaScript 解决方案。运行代码片段进行演示。
function checkPalindrome(line){
reverse_line=line.split("").reverse().join("");
return line==reverse_line;
}
alert("checkPalindrome(radar): "+checkPalindrome("radar"));
答案 38 :(得分：1)
我不得不为编程挑战做这件事，这是我的Haskell片段：
isPalindrome :: String -> Bool
isPalindrome n = (n == reverse n)
答案 39 :(得分：1)
的Perl：
sub is_palindrome {
my $s = lc shift; # normalize case
$s =~ s/\W//g; # strip non-word characters
return $s eq reverse $s;
}
答案 40 :(得分：0)
public class palindrome {
public static void main(String[] args) {
StringBuffer strBuf1 = new StringBuffer("malayalam");
StringBuffer strBuf2 = new StringBuffer("malayalam");
strBuf2.reverse();
System.out.println(strBuf2);
System.out.println((strBuf1.toString()).equals(strBuf2.toString()));
if ((strBuf1.toString()).equals(strBuf2.toString()))
System.out.println("palindrome");
else
System.out.println("not a palindrome");
}
}
答案 41 :(得分：0)
带堆栈的Java。
public class StackPalindrome {
public boolean isPalindrome(String s) throws OverFlowException,EmptyStackException{
boolean isPal=false;
String pal="";
char letter;
if (s==" ")
return true;
else{
s=s.toLowerCase();
for(int i=0;i<s.length();i++){
letter=s.charAt(i);
char[] alphabet={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
for(int j=0; j<alphabet.length;j++){
/*removing punctuations*/
if ((String.valueOf(letter)).equals(String.valueOf(alphabet[j]))){
pal +=letter;
}
}
}
int len=pal.length();
char[] palArray=new char[len];
for(int r=0;r<len;r++){
palArray[r]=pal.charAt(r);
}
ArrayStack palStack=new ArrayStack(len);
for(int k=0;k<palArray.length;k++){
palStack.push(palArray[k]);
}
for (int i=0;i<len;i++){
if ((palStack.topAndpop()).equals(palArray[i]))
isPal=true;
else
isPal=false;
}
return isPal;
}
}
public static void main (String args[]) throws EmptyStackException,OverFlowException{
StackPalindrome s=new StackPalindrome();
System.out.println(s.isPalindrome("“Ma,” Jerome raps pot top, “Spare more jam!”"));
}
答案 42 :(得分：0)
常规方法：
flag = True // Assume palindrome is true
for i from 0 to n/2
{ compare element[i] and element[n-i-1] // 0 to n-1
if not equal set flag = False
break }
return flag
有一种更好的机器优化方法，它使用XOR但具有相同的复杂性
XOR方法：
n = length of string
mid_element = element[n/2 +1]
for i from 0 to n
{ t_xor = element[i] xor element[i+1] }
if n is odd compare mid_element and t_xor
else check t_xor is zero
答案 43 :(得分：0)
如果您可以使用Java API和其他存储：
public static final boolean isPalindromeWithAdditionalStorage(String string) {
String reversed = new StringBuilder(string).reverse().toString();
return string.equals(reversed);
}
在Java中需要一个就地方法：
public static final boolean isPalindromeInPlace(String string) {
char[] array = string.toCharArray();
int length = array.length-1;
int half = Math.round(array.length/2);
char a,b;
for (int i=length; i>=half; i--) {
a = array[length-i];
b = array[i];
if (a != b) return false;
}
return true;
}
答案 44 :(得分：0)
//Single program for Both String or Integer to check palindrome
//In java with out using string functions like reverse and equals method also and display matching characters also
package com.practice;
import java.util.Scanner;
public class Pallindrome {
public static void main(String args[]) {
Scanner sc=new Scanner(System.in);
int i=0,j=0,k,count=0;
String input,temp;
System.out.println("Enter the String or Integer");
input=sc.nextLine();
temp=input;
k=temp.length()-1;
for(i=0;i<=input.length()-1;i++) {
if(input.charAt(j)==temp.charAt(k)) {
count++;
}
//For matching characters
j++;
k--;
}
System.out.println("Matching Characters = "+count);
if(count==input.length()) {
System.out.println("It's a pallindrome");
}
else {
System.out.println("It's not a pallindrome");
}
}
}
答案 45 :(得分：0)
public static boolean isPalindrome(String str) {
return str.equals(new StringBuilder(str).reverse().toString());
}
对于早于1.5的Java版本，
public static boolean isPalindrome(String str) {
return str.equals(new StringBuffer().append(str).reverse().toString());
}
或
public static boolean istPalindrom(char[] word){
int i1 = 0;
int i2 = word.length - 1;
while (i2 > i1) {
if (word[i1] != word[i2]) {
return false;
}
++i1;
--i2;
}
return true;
}
答案 46 :(得分：0)
public static boolean isPalindrome( String str ) {
int count = str.length() ;
int i, j = count - 1 ;
for ( i = 0 ; i < count ; i++ ) {
if ( str.charAt(i) != str.charAt(j) ) return false ;
if ( i == j ) return true ;
j-- ;
}
return true ;
}
答案 47 :(得分：0)
这个PHP示例怎么样：
function noitcnuf( $returnstrrevverrtsnruter, $functionnoitcnuf) {
$returnstrrev = "returnstrrevverrtsnruter";
$verrtsnruter = $functionnoitcnuf;
return (strrev ($verrtsnruter) == $functionnoitcnuf) ;
}
答案 48 :(得分：0)
C＃版本：
假设MyString是一个char []，在验证字符串后返回Method，它会忽略空格和＆lt;，＆gt;，但是这可以扩展为忽略更多，可能是实现了忽略列表的正则表达式匹配。
public bool IsPalindrome()
if (MyString.Length == 0)
return false;
int len = MyString.Length - 1;
int first = 0;
int second = 0;
for (int i = 0, j = len; i <= len / 2; i++, j--)
{
while (i<j && MyString[i] == ' ' || MyString[i] == ',')
i++;
while(j>i && MyString[j] == ' ' || MyString[j] == ',')
j--;
if ((i == len / 2) && (i == j))
return true;
first = MyString[i] >= 97 && MyString[i] <= 122 ? MyString[i] - 32 : MyString[i];
second = MyString[j] >= 97 && MyString[j] <= 122 ? MyString[j] - 32 : MyString[j];
if (first != second)
return false;
}
return true;
}
快速测试用例
负 1. ABCDA 2. AB CBAG 3.＃$ BDA 4. NULL / EMPTY
正 1. ABCBA A，男人计划运河，巴拿马 ABC ABC 4. M 5. ACCB
让我知道任何问题/错误。
答案 49 :(得分：0)
普通C中不区分大小写，const - 友好版本，忽略非字母数字字符（例如空格/标点符号）。因此，它实际上将传递经典，如“一个人，一个计划，一条运河，巴拿马”。
int ispalin(const char *b)
{
const char *e = b;
while (*++e);
while (--e >= b)
{
if (isalnum(*e))
{
while (*b && !isalnum(*b)) ++b;
if (toupper(*b++) != toupper(*e)) return 0;
}
}
return 1;
}
答案 50 :(得分：0)
面试官将寻找一些关于如何解决这个问题的逻辑： 请考虑以下java代码：
一旦你知道你的答案就会快速返回，并且不会浪费资源。
public static boolean isPalindrome（String s）{
if (s == null || s.length() == 0 || s.length() == 1)
return false;
String ss = s.toLowerCase().replaceAll("/[^a-z]/", "");
for (int i = 0; i < ss.length()/2; i++)
if (ss.charAt(i) != ss.charAt(ss.length() - 1 - i))
return false;
return true;
}
答案 51 :(得分：0)
template <class T>
class Node {
public:
Node() {
this->setNext(nullptr);
this->setPrev(nullptr);
}
Node *getNext() const {
return next;
}
void setNext(Node *next) {
Node::next = next;
}
Node *getPrev() const {
return prev;
}
void setPrev(Node *prev) {
Node::prev = prev;
}
T getItem() const {
return item;
}
void setItem(T item) {
Node::item = item;
}
private:
Node* next;
Node* prev;
T item;
};
答案 52 :(得分：0)
public bool IsPalindrome(string s)
{
string formattedString = s.Replace(" ", string.Empty).ToLower();
for (int i = 0; i < formattedString.Length / 2; i++)
{
if (formattedString[i] != formattedString[formattedString.Length - 1 - i])
return false;
}
return true;
}
这种方法适用于像“我看到的老鼠”这样的刺痛。但我觉得我们需要通过正则表达式消除特殊性格。
答案 53 :(得分：0)
<强> Scala的
def pal(s:String) = Symbol(s) equals Symbol(s.reverse)
答案 54 :(得分：0)
Const-correct C / C ++指针解决方案。循环中的最小操作。
int IsPalindrome (const char *str)
{
const unsigned len = strlen(str);
const char *end = &str[len-1];
while (str < end)
if (*str++ != *end--)
return 0;
return 1;
}
答案 55 :(得分：0)
这是我在进行示例服务器控件时使用的另一个C＃。它可以在ASP.NET 3.5 Step by Step（MS Press）一书中找到。这是两种方法，一种是剥离非字母数字，另一种是检查回文。
protected string StripNonAlphanumerics(string str)
{
string strStripped = (String)str.Clone();
if (str != null)
{
char[] rgc = strStripped.ToCharArray();
int i = 0;
foreach (char c in rgc)
{
if (char.IsLetterOrDigit(c))
{
i++;
}
else
{
strStripped = strStripped.Remove(i, 1);
}
}
}
return strStripped;
}
protected bool CheckForPalindrome()
{
if (this.Text != null)
{
String strControlText = this.Text;
String strTextToUpper = null;
strTextToUpper = Text.ToUpper();
strControlText =
this.StripNonAlphanumerics(strTextToUpper);
char[] rgcReverse = strControlText.ToCharArray();
Array.Reverse(rgcReverse);
String strReverse = new string(rgcReverse);
if (strControlText == strReverse)
{
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
答案 56 :(得分：0)
C＃中的简易模式，仅使用基类库
编辑：刚看到有人做了Array.Reverse
public bool IsPalindrome(string s)
{
if (String.IsNullOrEmpty(s))
{
return false;
}
else
{
char[] t = s.ToCharArray();
Array.Reverse(t);
string u = new string(t);
if (s.ToLower() == u.ToLower())
{
return true;
}
}
return false;
}
答案 57 :(得分：0)
以下是另外两个Perl版本，两者都不使用reverse。两者都使用将字符串的第一个字符与最后一个字符进行比较的基本算法，然后丢弃它们并重复测试，但它们使用不同的方法获取单个字符（第一个使用正则表达式一次剥离它们，第二个split将字符串转换为字符数组。）
#!/usr/bin/perl
my @strings = ("A man, a plan, a canal, Panama.", "A Toyota's a Toyota.",
"A", "", "As well as some non-palindromes.");
for my $string (@strings) {
print is_palindrome($string) ? "'$string' is a palindrome (1)\n"
: "'$string' is not a palindrome (1)\n";
print is_palindrome2($string) ? "'$string' is a palindrome (2)\n"
: "'$string' is not a palindrome (2)\n";
}
sub is_palindrome {
my $str = lc shift;
$str =~ tr/a-z//cd;
while ($str =~ s/^(.)(.*)(.)$/\2/) {
return unless $1 eq $3;
}
return 1;
}
sub is_palindrome2 {
my $str = lc shift;
$str =~ tr/a-z//cd;
my @chars = split '', $str;
while (@chars && shift @chars eq pop @chars) {};
return scalar @chars <= 1;
}
答案 58 :(得分：0)
高效的C ++版本：
template< typename Iterator >
bool is_palindrome( Iterator first, Iterator last, std::locale const& loc = std::locale("") )
{
if ( first == last )
return true;
for( --last; first < last; ++first, --last )
{
while( ! std::isalnum( *first, loc ) && first < last )
++first;
while( ! std::isalnum( *last, loc ) && first < last )
--last;
if ( std::tolower( *first, loc ) != std::tolower( *last, loc ) )
return false;
}
return true;
}
答案 59 :(得分：0)
set l = index of left most character in word
set r = index of right most character in word
loop while(l < r)
begin
if letter at l does not equal letter at r
word is not palindrome
else
increase l and decrease r
end
word is palindrome
答案 60 :(得分：0)
剥离不属于A-Z或a-z之间的任何字符的解决方案都是以英语为中心的。带有变音符号（如à或é）的字母将被删除！
根据维基百科：
变音符号的处理方式各不相同。在捷克语和西班牙语等语言中，带有变音符号或重音符号（波浪号除外）的字母在字母表中没有单独的位置，因此无论重复的字母是否具有装饰，都可以保留回文。但是，在瑞典语和其他北欧语言中，带有环（å）的A和A是不同的字母，必须完全镜像才能被视为真正的回文。
因此，为了涵盖许多其他语言，最好使用整理将变音符号转换为等效的非变音符号，或者在适当时单独保留，然后在比较之前删除空格和标点符号。
答案 61 :(得分：0)
这一切都很好，但有没有办法在算法上做得更好？我曾在接受采访时被要求识别线性时间的回文和恒定空间。
我想不出任何事情，我仍然不能。
（如果有帮助的话，我问采访者答案是什么。他说你可以构造一对哈希函数，这样当它们将字符串作为回文时，它们将给定字符串哈希到相同的值。我有不知道你将如何实际制作这对功能。）
答案 62 :(得分：0)
我还没有看到任何递归，所以这里......
import re
r = re.compile("[^0-9a-zA-Z]")
def is_pal(s):
def inner_pal(s):
if len(s) == 0:
return True
elif s[0] == s[-1]:
return inner_pal(s[1:-1])
else:
return False
r = re.compile("[^0-9a-zA-Z]")
return inner_pal(r.sub("", s).lower())
答案 63 :(得分：0)
此处没有单一解决方案，其中考虑到回文也可以基于单位单位，而不仅仅是字符单位。
这意味着没有一个给定的解决方案对于“女孩，穿着比基尼，盯着男孩，看到男孩盯着比基尼洗澡的女孩”这样的回文都是真的。
这是C＃中的黑客攻击版本。我确信它不需要正则表达式，但它确实与上面的比基尼回文一样有效，就像“男人，计划，运河 - 巴拿马！”一样。
static bool IsPalindrome(string text)
{
bool isPalindrome = IsCharacterPalindrome(text);
if (!isPalindrome)
{
isPalindrome = IsPhrasePalindrome(text);
}
return isPalindrome;
}
static bool IsCharacterPalindrome(string text)
{
String clean = Regex.Replace(text.ToLower(), "[^A-z0-9]", String.Empty, RegexOptions.Compiled);
bool isPalindrome = false;
if (!String.IsNullOrEmpty(clean) && clean.Length > 1)
{
isPalindrome = true;
for (int i = 0, count = clean.Length / 2 + 1; i < count; i++)
{
if (clean[i] != clean[clean.Length - 1 - i])
{
isPalindrome = false; break;
}
}
}
return isPalindrome;
}
static bool IsPhrasePalindrome(string text)
{
bool isPalindrome = false;
String clean = Regex.Replace(text.ToLower(), @"[^A-z0-9\s]", " ", RegexOptions.Compiled).Trim();
String[] words = Regex.Split(clean, @"\s+");
if (words.Length > 1)
{
isPalindrome = true;
for (int i = 0, count = words.Length / 2 + 1; i < count; i++)
{
if (words[i] != words[words.Length - 1 - i])
{
isPalindrome = false; break;
}
}
}
return isPalindrome;
}
答案 64 :(得分：0)
boolean IsPalindrome(string s) {
return s = s.Reverse();
}
答案 65 :(得分：0)
答案 66 :(得分：0)
如果我们正在寻找数字和简单的单词，那么就给出了许多正确答案。
然而，如果我们正在寻找我们通常用书面语言看待的回文（例如，“狗，恐慌，在宝塔中！”），正确的答案是从两端开始迭代。句子，单独跳过非字母数字字符，如果发现任何不匹配，则返回false。
i = 0; j = length-1;
while( true ) {
while( i < j && !is_alphanumeric( str[i] ) ) i++;
while( i < j && !is_alphanumeric( str[j] ) ) j--;
if( i >= j ) return true;
if( tolower(string[i]) != tolower(string[j]) ) return false;
i++; j--;
}
当然，剥离无效字符，反转生成的字符串并将其与原始字符串进行比较也有效。它归结为你正在使用的语言类型。
答案 67 :(得分：0)
来自Delphi的另一个，我认为它比提交的其他Delphi示例更严格一些。这很容易变成一场高尔夫比赛，但我试图让我的比赛变得可读。
编辑0：我对性能特征感到好奇，所以我做了一点测试。在我的机器上，我对60个字符的字符串运行了这个函数5000万次，花了5秒钟。
function TForm1.IsPalindrome(txt: string): boolean;
var
i, halfway, len : integer;
begin
Result := True;
len := Length(txt);
{
special cases:
an empty string is *never* a palindrome
a 1-character string is *always* a palindrome
}
case len of
0 : Result := False;
1 : Result := True;
else begin
halfway := Round((len/2) - (1/2)); //if odd, round down to get 1/2way pt
//scan half of our string, make sure it is mirrored on the other half
for i := 1 to halfway do begin
if txt[i] <> txt[len-(i-1)] then begin
Result := False;
Break;
end; //if we found a non-mirrored character
end; //for 1st half of string
end; //else not a special case
end; //case
end;
这是同样的事情，在C＃中，除了我留下了多个退出点，我不喜欢。
private bool IsPalindrome(string txt) {
int len = txt.Length;
/*
Special cases:
An empty string is *never* a palindrome
A 1-character string is *always* a palindrome
*/
switch (len) {
case 0: return false;
case 1: return true;
} //switch
int halfway = (len / 2);
//scan half of our string, make sure it is mirrored on the other half
for (int i = 0; i < halfway; ++i) {
if (txt.Substring(i,1) != txt.Substring(len - i - 1,1)) {
return false;
} //if
} //for
return true;
}
答案 68 :(得分：0)
C＃3 - 一旦从头开始计算的字符与最后的字母匹配，它就会返回false：
static bool IsPalindrome(this string input)
{
char[] letters = input.ToUpper().ToCharArray();
int i = 0;
while( i < letters.Length / 2 )
if( letters[i] != letters[letters.Length - ++i] )
return false;
return true;
}