String 如何检查给定字符串是否为回文？

定义：

(defun palindrome(x) (string= x (reverse x)))

回文是一个单词、短语、数字或其他单位序列，具有在任意方向读取相同内容的特性

如何检查给定字符串是否为回文

这是不久前FAIQ（面试常见问题）中的一个问题，但主要使用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");
}

寻找各种语言的解决方案

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版本

语言不可知元代码然后

rev = StringReverse(originalString)
return ( rev == originalString );

这是我的c语言解决方案#

static bool isPalindrome（字符串s）
{
字符串allowedChars=“abcdefghijklmnopqrstuvwxyz”+
“1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ”；
字符串比较字符串=string.Empty；
string rev=string.Empty；
对于（int i=0；i-1）
{
比较+=c；
}
}
对于（int i=compareString.Length-1；i>=0；i--）
{
char c=比较字符串[i]；
rev+=c；
}
返回版本等于（比较，
StringComparison.CurrentCultureInogoreCase）；
}

Delphi
函数isAlindrome（常量s:string）：布尔值；
变量
i、 j：整数；
开始
结果：=假；
j:=长度（s）；
对于i:=1到长度（s）div 2不开始
如果s[i]s[j]，那么
出口
12月（j）；
结束；
结果：=真；
结束；

未优化的Python:

>>> def is_palindrome(s):
...     return s == s[::-1]

---

这里有一个python方法。注意：这并不是真正的“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

def IsPalindromeString（n）：
迈伦=伦（n）
i=0
当iWindows XP（可能也适用于2000）或更高版本的批处理脚本时：

@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

C#：林克

有很多方法可以做到这一点。我想关键是尽可能以最有效的方式（不循环字符串）完成。我会把它作为一个可以很容易反转的字符数组（使用C#）

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

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

boolean IsPalindrome（字符串s）{
对于（int i=0；i


编辑：删除循环中不必要的“
+1
”条件，并将保存的比较用于删除冗余长度比较。感谢评论
 使用良好的数据结构通常有助于给教授留下深刻印象：

将一半字符推到堆栈上（长度/2）。

弹出并比较每个字符，直到第一个字符不匹配。

如果堆栈有零个元素：回文。

*对于长度为奇数的字符串，请抛出中间字符。
以下是我的解决方案，无需使用strev。用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;
}

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

private静态bool Pal（字符串s）{
对于（int i=0；i
此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;
}

private静态布尔doPal（字符串测试）{
对于（int i=0；i
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!");
}

public boolean isPalindrome(String testString) {
    StringBuffer sb = new StringBuffer(testString);
    String reverseString = sb.reverse().toString();

    if(testString.equalsIgnoreCase(reverseString)) {
        return true;
    else {
        return false;
    }
}

公共类快速测试{
公共静态void main（字符串[]args）{
选中（“amanaplanacanala.toLowerCase（））；
选中（“helloworld.toLowerCase（））；
}
公共静态无效检查（字符串收敛）{
系统输出打印（aString+“：”）；
char[]chars=aString.toCharArray（）；
对于（int i=0，j=（chars.length-1）；i<（chars.length/2）；i++，j--）{
if（chars[i]！=chars[j]）{
System.out.println（“不是回文！”）；
返回；
}
}
System.out.println（“找到回文！”）；
}

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

删除所有非字母数字字符（空格、逗号、感叹号等），以允许使用上述完整句子和简单单词。
编辑：从注释中：

bool palindrome(std::string const& s) 
{ 
  return std::equal(s.begin(), s.end(), s.rbegin()); 
} 


<> > C++方式> < /P>
我使用优雅迭代器的天真实现。实际上，您可能会检查
并在前向迭代器超过字符串的中间标记后停止

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

}

#包括
#包括
使用名称空间std；
布尔回文（字符串foo）
{
字符串：：迭代器前端；
字符串：：反向迭代器返回；
bool is_palindrome=true；
for（front=foo.begin（），back=foo.rbegin（）；
是回文和前面！=foo.end（）&后面！=foo.rend（）；
++正面+背面
)
{
如果（*前！=*后）
is_回文=假；
}
返回是_回文；
}
int main（）
{
字符串a=“你好”，b=“拉瓦尔”；
cout这是一个处理不同大小写、标点和空格的Python版本

import string

def is_palindrome(palindrome):
    letters = palindrome.translate(string.maketrans("",""),
                  string.whitespace + string.punctuation).lower()
    return letters == letters[::-1]

编辑：厚颜无耻地从neater answer中盗取，删除了我以前版本中略显笨拙的列表处理。
Smalltalk中的三个版本，从最愚蠢到正确


在Smalltalk中，
=
是比较运算符：

isPalindrome: aString
    "Dumbest."
    ^ aString reverse = aString


消息
#translateToLowercase
以小写形式返回字符串：

isPalindrome: aString
    "Case insensitive"
    |lowercase|
    lowercase := aString translateToLowercase.
    ^ lowercase reverse = lowercase


在Smalltalk中，字符串是
集合
框架的一部分，您可以使用消息
#选择：然后集合：
，最后一个版本是：

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

另一个C++。对速度和大小进行了优化。
bool是回文（const std:：string&candidate）{
for（std:：string:：const_迭代器left=candidate.begin（），right=candidate.end（）；left<--right；++left）
如果（*左！=*右）
返回false；
返回true；
}
在Ruby中，转换为小写并去除所有非字母：

def isPalindrome( string )
    ( test = string.downcase.gsub( /[^a-z]/, '' ) ) == test.reverse
end

但那
#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;
}

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

class String
  def palindrome?
    (test = gsub(/[^A-Za-z]/, '').downcase) == test.reverse
  end
end

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

public boolean isPalindrome(String phrase) {
  phrase = phrase.toLowerCase().replaceAll("[^a-z]", "");
  return StringUtils.reverse(phrase).equals(phrase);
}

(defun palindrome(x) (string= x (reverse x)))

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

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

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

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

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

ispalin :: [Char] -> Bool
ispalin a = a == (let xi (y:my) = (xi my) ++ [y]; xi [] = [] in \x -> xi x) a

public boolean isPalindrome(String testString) {
    StringBuffer sb = new StringBuffer(testString);
    String reverseString = sb.reverse().toString();

    if(testString.equalsIgnoreCase(reverseString)) {
        return true;
    else {
        return false;
    }
}

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