如何检查一个数字是否是回文？

小开

最佳答案

这是欧拉计划的一个问题。当我在 Haskell 中解决这个问题时，我完全按照你的建议做了，把数字转换成字符串。然后检查字符串是否是回文字符串就变得很简单了。如果它表现得足够好，那么为什么还要费心让它变得更复杂呢？回文是一种词汇属性，而不是数学属性。

小开

将每个单独的数字压入一个堆栈，然后将它们弹出。如果前后都一样，那就是回文。

小开

对于任何给定的数字:

n = num;
rev = 0;
while (num > 0)
{
dig = num % 10;
rev = rev * 10 + dig;
num = num / 10;
}

如果 n == rev那么 num是一个回文:

cout << "Number " << (n == rev ? "IS" : "IS NOT") << " a palindrome" << endl;

小开

def ReverseNumber(n, partial=0):
if n == 0:
return partial
return ReverseNumber(n // 10, partial * 10 + n % 10)


trial = 123454321
if ReverseNumber(trial) == trial:
print("It's a Palindrome!")

只对整数有效。从问题陈述中还不清楚是否需要考虑浮点数或前导零。

小开

int is_palindrome(unsigned long orig)
{
unsigned long reversed = 0, n = orig;


while (n > 0)
{
reversed = reversed * 10 + n % 10;
n /= 10;
}


return orig == reversed;
}

小开

弹出第一个和最后一个数字，并比较他们，直到你用完。可能还剩下一个数字，也可能没有，但不管怎样，如果所有弹出的数字都匹配，那就是回文。

小开

我用一种非常粗暴的方式回答了欧拉问题。当然，当我访问新的解锁的相关论坛帖子时，会看到一个更加智能的算法。也就是说，一个叫 Begoner 的成员有这样一个新颖的方法，我决定用他的算法重新实现我的解决方案。他的版本是 Python (使用嵌套循环) ，我在 Clojure 中重新实现了它(使用单个循环/recur)。

给你们看点好玩的:

(defn palindrome? [n]
(let [len (count n)]
(and
(= (first n) (last n))
(or (>= 1 (count n))
(palindrome? (. n (substring 1 (dec len))))))))


(defn begoners-palindrome []
(loop [mx 0
mxI 0
mxJ 0
i 999
j 990]
(if (> i 100)
(let [product (* i j)]
(if (and (> product mx) (palindrome? (str product)))
(recur product i j
(if (> j 100) i (dec i))
(if (> j 100) (- j 11) 990))
(recur mx mxI mxJ
(if (> j 100) i (dec i))
(if (> j 100) (- j 11) 990))))
mx)))


(time (prn (begoners-palindrome)))

也有 Common Lisp 的答案，但对我来说是不可理喻的。

小开

为了好玩，这个也能用。

a = num;
b = 0;
if (a % 10 == 0)
return a == 0;
do {
b = 10 * b + a % 10;
if (a == b)
return true;
a = a / 10;
} while (a > b);
return a == b;

小开

下面是一个 Scheme 版本，它构造了一个可以对任何基进行操作的函数。它有一个冗余检查: 如果数字是基数的倍数(以0结尾) ，则快速返回 false。
它不能重建整个反向数字，只能重建一半。
这就够了。

(define make-palindrome-tester
(lambda (base)
(lambda (n)
(cond
((= 0 (modulo n base)) #f)
(else
(letrec
((Q (lambda (h t)
(cond
((< h t) #f)
((= h t) #t)
(else
(let*
((h2 (quotient h base))
(m  (- h (* h2 base))))
(cond
((= h2 t) #t)
(else
(Q h2 (+ (* base t) m))))))))))
(Q n 0)))))))

小开

一种比@sminks 方法的常数因子稍微好一点的方法:

num=n
lastDigit=0;
rev=0;
while (num>rev) {
lastDigit=num%10;
rev=rev*10+lastDigit;
num /=2;
}
if (num==rev) print PALINDROME; exit(0);
num=num*10+lastDigit; // This line is required as a number with odd number of bits will necessary end up being smaller even if it is a palindrome
if (num==rev) print PALINDROME

小开

F # 版本:

let reverseNumber n =
let rec loop acc = function
|0 -> acc
|x -> loop (acc * 10 + x % 10) (x/10)
loop 0 n


let isPalindrome = function
| x  when x = reverseNumber x -> true
| _ -> false

小开

如果一个数字的字符串表示是回文的，那么它就是回文的:

def is_palindrome(s):
return all(s[i] == s[-(i + 1)] for i in range(len(s)//2))


def number_palindrome(n):
return is_palindrome(str(n))

小开

除了把数字变成一个字符串然后把它反过来。

为什么不考虑这个解决方案呢？它易于实现和可读.如果在没有电脑的情况下问你 2**10-23是否是十进制回文，你肯定会用十进制来测试它。

至少在 Python 中，“字符串运算比算术慢”的口号实际上是错误的。我比较了 Smink 的算法和简单的字符串反转 int(str(i)[::-1])。在速度上没有显著差异-发生字符串反转的速度略快。

在编译语言(C/C + +)中，这个口号可能成立，但是存在大量错误溢出的风险。

def reverse(n):
rev = 0
while n > 0:
rev = rev * 10 + n % 10
n = n // 10
return rev


upper = 10**6


def strung():
for i in range(upper):
int(str(i)[::-1])


def arithmetic():
for i in range(upper):
reverse(i)


import timeit
print "strung", timeit.timeit("strung()", setup="from __main__ import strung", number=1)
print "arithmetic", timeit.timeit("arithmetic()", setup="from __main__ import arithmetic", number=1)

以秒为单位的结果(越小越好) :

字符串1.50960231881 1.69729960569

小开

def palindrome(n):
d = []
while (n > 0):
d.append(n % 10)
n //= 10
for i in range(len(d)/2):
if (d[i] != d[-(i+1)]):
return "Fail."
return "Pass."

小开

试试这个:

reverse = 0;
remainder = 0;
count = 0;
while (number > reverse)
{
remainder = number % 10;
reverse = reverse * 10 + remainder;
number = number / 10;
count++;
}
Console.WriteLine(count);
if (reverse == number)
{
Console.WriteLine("Your number is a palindrome");
}
else
{
number = number * 10 + remainder;
if (reverse == number)
Console.WriteLine("your number is a palindrome");
else
Console.WriteLine("your number is not a palindrome");
}
Console.ReadLine();
}
}

小开

下面是一个在 python 中使用列表作为堆栈的解决方案:

def isPalindromicNum(n):
"""
is 'n' a palindromic number?
"""
ns = list(str(n))
for n in ns:
if n != ns.pop():
return False
return True

弹出堆栈只考虑数字的最右边进行比较，因此很快就无法减少检查

小开

 public class Numbers
{
public static void main(int givenNum)
{
int n= givenNum
int rev=0;


while(n>0)
{
//To extract the last digit
int digit=n%10;


//To store it in reverse
rev=(rev*10)+digit;


//To throw the last digit
n=n/10;
}


//To check if a number is palindrome or not
if(rev==givenNum)
{
System.out.println(givenNum+"is a palindrome ");
}
else
{
System.out.pritnln(givenNum+"is not a palindrome");
}
}
}

小开

大多数答案上面都有一个小问题，那就是 int 变量可能会溢出。

请参阅 http://articles.leetcode.com/palindrome-number/

boolean isPalindrome(int x) {
if (x < 0)
return false;
int div = 1;
while (x / div >= 10) {
div *= 10;
}
while (x != 0) {
int l = x / div;
int r = x % 10;
if (l != r)
return false;
x = (x % div) / 10;
div /= 100;
}
return true;
}

小开

let isPalindrome (n:int) =
let l1 = n.ToString() |> List.ofSeq |> List.rev
let rec isPalindromeInt l1 l2 =
match (l1,l2) with
| (h1::rest1,h2::rest2) -> if (h1 = h2) then isPalindromeInt rest1 rest2 else false
| _ -> true
isPalindromeInt l1 (n.ToString() |> List.ofSeq)

小开

checkPalindrome(int number)
{
int lsd, msd,len;
len = log10(number);
while(number)
{
msd = (number/pow(10,len)); // "most significant digit"
lsd = number%10; // "least significant digit"
if(lsd==msd)
{
number/=10; // change of LSD
number-=msd*pow(10,--len); // change of MSD, due to change of MSD
len-=1; // due to change in LSD
} else {return 1;}
}
return 0;
}

小开

递归方式，不是很有效，只是提供了一个选项

(Python 代码)

def isPalindrome(num):
size = len(str(num))
demoninator = 10**(size-1)
return isPalindromeHelper(num, size, demoninator)


def isPalindromeHelper(num, size, demoninator):
"""wrapper function, used in recursive"""
if size <=1:
return True
else:
if num/demoninator != num%10:
return False
# shrink the size, num and denominator
num %= demoninator
num /= 10
size -= 2
demoninator /=100
return isPalindromeHelper(num, size, demoninator)

小开

似乎最简单的方法就是找到对立的数字，然后比较两者:

int max =(int)(Math.random()*100001);


int i;
int num = max; //a var used in the tests
int size; //the number of digits in the original number
int opos = 0; // the oposite number
int nsize = 1;


System.out.println(max);


for(i = 1; num>10; i++)
{
num = num/10;
}


System.out.println("this number has "+i+" digits");


size = i; //setting the digit number to a var for later use






num = max;


for(i=1;i<size;i++)
{
nsize *=10;
}




while(num>1)
{
opos += (num%10)*nsize;
num/=10;
nsize/=10;
}


System.out.println("and the number backwards is "+opos);


if (opos == max )
{
System.out.println("palindrome!!");
}
else
{
System.out.println("aint no palindrome!");
}

小开

试试这个:

print('!* To Find Palindrome Number')


def Palindrome_Number():


n = input('Enter Number to check for palindromee')
m=n
a = 0


while(m!=0):
a = m % 10 + a * 10
m = m / 10


if( n == a):
print('%d is a palindrome number' %n)
else:
print('%d is not a palindrome number' %n)

只要回调函数

小开

检查给定数字是否为回文(Java 代码)

class CheckPalindrome{
public static void main(String str[]){
int a=242, n=a, b=a, rev=0;
while(n>0){
a=n%10;  n=n/10;rev=rev*10+a;
System.out.println(a+"  "+n+"  "+rev);  // to see the logic
}
if(rev==b)  System.out.println("Palindrome");
else        System.out.println("Not Palindrome");
}
}

小开

下面是在 c + + 中使用模板的另一个解决方案。此解决方案适用于不区分大小写的回文字符串比较。

template <typename bidirection_iter>
bool palindrome(bidirection_iter first, bidirection_iter last)
{
while(first != last && first != --last)
{
if(::toupper(*first) != ::toupper(*last))
return false;
else
first++;
}
return true;
}

小开

有个办法。

class Palindrome_Number{
void display(int a){
int count=0;
int n=a;
int n1=a;
while(a>0){
count++;
a=a/10;
}
double b=0.0d;
while(n>0){
b+=(n%10)*(Math.pow(10,count-1));
count--;
n=n/10;
}
if(b==(double)n1){
System.out.println("Palindrome number");
}
else{
System.out.println("Not a palindrome number");
}
}
}

小开

我使用了常规方法，将 number 转换为 string，然后进一步将 string 转换为 charArray。
遍历 charArray 并查找位置处的 number 是否相等。
注意: 没有反转字符串。

public bool IsPalindrome(int num)
{
string st = num.ToString();
char[] arr = st.ToCharArray();
int len = arr.Length;
if (len <= 1)
{
return false;
}
for (int i = 0; i < arr.Length; i++)
{
if (arr[i] == arr[len - 1])
{
if (i >= len)
{
return true;
}
len--;
}
else
{
break;
}
}
return false;
}

小开

这里提供的许多解决方案都是反转整数并将其存储在一个变量中，这个变量使用额外的空间 O(n)，但这里有一个使用 O(1)空间的解决方案。

def isPalindrome(num):
if num < 0:
return False
if num == 0:
return True
from math import log10
length = int(log10(num))
while length > 0:
right = num % 10
left = num / 10**length
if right != left:
return False
num %= 10**length
num /= 10
length -= 2
return True

小开

由于它的紧凑性，我总是使用这个 python 解决方案。

def isPalindrome(number):
return int(str(number)[::-1])==number

小开

int reverse(int num)
{
assert(num >= 0);   // for non-negative integers only.
int rev = 0;
while (num != 0)
{
rev = rev * 10 + num % 10;
num /= 10;
}
return rev;
}

这似乎也起作用，但你有没有考虑过反向数字可能溢出的可能性？如果它溢出，那么行为是特定于语言的(对于 Java 来说，这个数字包含了溢出，但是在 C/C + + 中，它的行为是未定义的)。真恶心。

事实证明，从两端进行比较更容易。首先，比较第一个数字和最后一个数字。如果它们不相同，就不能是回文。如果它们是相同的，从两端删除一个数字，然后继续，直到没有剩下的数字，这样你就得出结论，它一定是一个回文。

现在，获取和切割最后一个数字很容易。然而，以通用的方式获取和切割第一个数字需要一些思考。下面的解决方案可以解决这个问题。

int isIntPalindrome(int x)
{
if (x < 0)
return 0;
int div = 1;
while (x / div >= 10)
{
div *= 10;
}


while (x != 0)
{
int l = x / div;
int r = x % 10;
if (l != r)
return 0;
x = (x % div) / 10;
div /= 100;
}
return 1;
}

小开

戈兰版本:

package main


import "fmt"


func main() {
n := 123454321
r := reverse(n)
fmt.Println(r == n)
}


func reverse(n int) int {
r := 0
for {
if n > 0 {
r = r*10 + n%10
n = n / 10
} else {
break
}
}
return r
}

小开

在 Python 中，有一种快速、迭代的方法。

def reverse(n):
newnum=0
while n>0:
newnum = newnum*10 + n % 10
n//=10
return newnum


def palindrome(n):
return n == reverse(n)

这也防止了递归的内存问题(比如 Java 中的 StackOverflow 错误)

小开

我知道的最快的方法:

bool is_pal(int n) {
if (n % 10 == 0) return 0;
int r = 0;
while (r < n) {
r = 10 * r + n % 10;
n /= 10;
}
return n == r || n == r / 10;
}

小开

num = int(raw_input())
list_num = list(str(num))
if list_num[::-1] == list_num:
print "Its a palindrome"
else:
print "Its not a palindrom"

小开

我不确定这是不是最好的答案，而且我还是个新手(Java 语言)

import java.util.*;


public class Palin {


public static void main(String[] args) {
Random randInt = new Random();


Scanner kbd = new Scanner(System.in);
int t = kbd.nextInt(); //# of test cases;
String[] arrPalin = new String[t]; //array of inputs;
String[] nextPalin = new String[t];
for (int i = 0; i < t; i++) {
arrPalin[i] = String.valueOf(randInt.nextInt(2147483646) + 1);
System.out.println(arrPalin[i]);
}


final long startTime = System.nanoTime();


for (int i = 0; i < t; i++) {
nextPalin[i] = (unmatcher(incrementer(switcher(match(arrPalin[i])))));
}


final long duration = System.nanoTime() - startTime;


for (int i = 0; i < t; i++) {
System.out.println(nextPalin[i]);
}


System.out.println(duration);


}


public static String match(String N) {
int length = N.length();


//Initialize a string with length of N
char[] chars = new char[length];
Arrays.fill(chars, '0');


int count = 1;


for (int i = 0; i < length; i++) {
if ((i%2) == 0) { //at i = even.
if (i == 0) {
chars[i] = N.charAt(i);
} else
chars[i] = N.charAt(i/2);
} else //at i = odd
chars[i] = N.charAt(length - count);
count++;
}


return String.valueOf(chars);
}


public static String switcher(String N) {
int length = N.length();
char[] chars = new char[length];
Arrays.fill(chars, '0');


for (int i = 0; i < length; i++) {
if (i != 0) {
if ((i % 2) == 0) {
chars[i] = N.charAt(i);
} else if ((i % 2) != 0) {
chars[i] = N.charAt(i - 1);
}
}
if (i == 0) {
chars[0] = N.charAt(0);
}
}
return String.valueOf(chars);
}


public static String incrementer(String N) {
int length = N.length();
char[] chars = new char[length];
Arrays.fill(chars, '0');


char[] newN = N.toCharArray();


String returnVal;


int numOne, numTwo;


if ((length % 2) == 0) {
numOne = N.charAt(length-1);
numTwo = N.charAt(length-2);
newN[length-1] = (char)(numOne+1);
newN[length-2] = (char)(numTwo+1);
returnVal = String.valueOf(newN);
} else {
numOne = N.charAt(length-1);
newN[length-1] = (char)(numOne+1);
returnVal = String.valueOf(newN);
}
return returnVal;
}


public static String unmatcher(String N) {
int length = N.length();
char[] chars = new char[length];
Arrays.fill(chars, '0');
char[] newN = N.toCharArray();


for (int i = 0; i < length; i++) {
if (((i % 2) == 0) && (i != 0)) { // for i > 0, even
newN[i / 2] = N.charAt(i);
} else if ((i % 2) == 0 && (i == 0)) { // for i = 0
newN[0] = N.charAt(0);
}
}
for (int i = (length/2); i < length; i++) {
newN[i] = newN[Math.abs(i - (length - 1))];
}


return String.valueOf(newN);
}




}

所以对于这段代码，输入一个数字(我随机输入我想要的数字) , 它将进行转换，例如输入是172345到157423。然后它会把它改为117722，如果偶数改为117733，如果单数改为最后一个数字。那就改成173371。它不是特别地寻找回文，而是寻找下一个最高的回文数。

小开

public class PalindromePrime   {
private static int g ,n =0,i,m ;
     

private javax.swing.JTextField jTextField;
     



static String b ="";
private static Scanner scanner = new Scanner( System.in );
public static void main(String [] args) throws IOException {
System.out.print(" Please Inter Data : ");
g = scanner.nextInt();
        

System.out.print(" Please Inter Data 2  : ");
m = scanner.nextInt();
        

count(g,m);
}


public static    int count(int L, int R) {
int resultNum = 0;
    

for( i= L ; i<= R ;i++){
int count= 0 ;
for( n = i ; n >=1 ;n -- ){
if(i%n==0){
count = count + 1 ;
//  System.out.println("  Data : \n "  +count );
}
}
if(count == 2)
{
//b = b +i + "" ;
                

String ss=  String .valueOf(i);
//  System.out.print("\n" +i );
if(isPalindrome(i))
{
//0 System.out.println("Number : " + i + " is   a palindrome");
                

//number2[b] = Integer.parseInt(number_ayy[b]);
                        

//String s = String .valueOf(i);
//System.out.printf("123456", s);
resultNum++;
}
else{
//*System.out.println("Number : " + i + " is Not  a palindrome");
}
//System.out.println("  Data : \n " +ss.length()  );
}
//  palindrome(i);
}
        

//  System.out.print("  Data  : ");
//  System.out.println("  Data : \n "  +b );
return resultNum;
}
    

@SuppressWarnings("unused")
public static boolean isPalindrome(int number  ) {
int p = number; // ประกาศ  p เป็น int ให้เท่ากับ number ของ ตัวที่ มาจาก method
int r = 0; //ประกาศ r เป็น int โดยให้มีค่าเรื่องต้นเท่ากับ 0
int w = 0 ;
while (p != 0) {  // เงื่อนไข While ถ้า p ไม่เท่ากับ 0  เช่น  2!= 0 จริง  เข้า
w = p % 10; // ประกาศตัว แปร W ให้ เท่ากับค่า p ที่มาจาก parramiter ให้ & mod กับ  10 คือ เช่น  2 % 10 = 2 ; w= 2 ; 3% 10 ; w =3
r = r * 10 + w;  // (ให้  R ที่มาจาก การประกาศค่ตัวแปร แล้ว * 10) + w  จะมาจากค่า w = p % 10; ที่ mod ไว้  เช่น 0*10 + 2 = 2
p = p / 10;  //แล้วใช้ p ที่จมาจากตัว paramiter แล้วมาหาร  10  เพราะถ้าไม่มี ก็จะสามารถพิมพ์ค่าออกมาได้  || ทำไงก็ได้ให้เป็น 0  และเอามาแทนค่ตัวต่อไป
}


// 1 วนวูปเช็คว่า   (p != 0) หรือไม่   โดย  p มาจาก p = number ที่รับมา
// 2 r = (r * 10) + (p%10) ;
        

//3   p = p /10 ; เพื่อเช็ค  ว่าให้มันเป็น 0 เพื่อหลุด Loop
if (number == r) {
// for(int count = 0 ; count <i ;count ++){
String s1 = String.valueOf(i);
        

//countLines(s1);
System.out.println("Number : " + "'"+s1 +"'"+"  is   a palindrome");


return true; //เรียก return ไป
}
return false;
}
    

public static int countLines(String str)
{
if (str == null || str.length() == 0)
return 0;
int lines = 1;
int len = str.length();
for( int pos = 0; pos < len; pos++) {
char c = str.charAt(pos);
if( c == '\r' ) {
System.out.println("Line 0 : " + "'"+str );
                

lines++;
if ( pos+1 < len && str.charAt(pos+1) == '\n' )
                    

System.out.println("Line : " + "'"+str );
                    

pos++;
} else if( c == '\n' ) {
lines++;
                

System.out.println("Line 2 : " + "'"+str );
}
}
return lines;
}
    

public static int countLines1(String sd) throws IOException {
LineNumberReader lineNumberReader = new LineNumberReader(new StringReader(sd));
int count = 0 ;
System.out.printf("Line  : " , count = count + 1 );
lineNumberReader.skip(Long.MAX_VALUE);
return lineNumberReader.getLineNumber();
}
}

小开

public static void main(String args[])
{
System.out.print("Enter a number: ");
Scanner input = new Scanner(System.in);
int num = input.nextInt();
int number = num;
int reversenum = 0;
while (num != 0)
{
reversenum = reversenum * 10;
reversenum = reversenum + num % 10;
num = num / 10;
}


if (number == reversenum)
System.out.println("The reverse number is " + reversenum + "\nThen the number is palindrome.");
else
System.out.println("The reverse number is " + reversenum + "\nThen the number is not palindrome.");


}

小开

红宝石中的递归解决方案，不将数字转换为字符串。

def palindrome?(x, a=x, b=0)
return x==b if a<1
palindrome?(x, a/10, b*10 + a%10)
end


palindrome?(55655)

小开

此代码将 int 转换为 String，然后检查字符串是否为 pallindrome。它的优点在于速度快，缺点在于它将 int 转换为 String，从而与问题的完美解决方案妥协。

static int pallindrome=41012;
static String pallindromer=(Integer.toString(pallindrome));
static int length=pallindromer.length();


public static void main(String[] args) {
pallindrome(0);
System.out.println("It's a pallindrome");
}


static void pallindrome(int index){
if(pallindromer.charAt(index)==pallindromer.charAt(length-(index+1))){
if(index<length-1){
pallindrome(++index);
}
}
else{
System.out.println("Not a pallindrome");
System.exit(0);
}
}

小开

我没有注意到任何解决这个问题的方法没有使用额外的空间，也就是说，我看到的所有解决方案要么使用一个字符串，要么使用另一个整数来反转数字，或者使用其他一些数据结构。

尽管像 Java 这样的语言围绕整数溢出展开，但是在像 C (尝试在 Java 中逆转2147483647(Integer.MAX _ VALUE))这样的语言中，这种行为是未定义的
变通方法可能是使用一个长的或其他东西，但是，在风格上，我不太喜欢这种方法。

回文数的概念是数字前后读应该是一样的。很好。利用这些信息，我们可以比较第一个数字和最后一个数字。诀窍是，对于第一个数字，我们需要数字的顺序。比如说12321。除以10000我们得到了领先的1。尾随的1可以通过使用带有10的 mod 来检索。现在，减少到232。(12321 % 10000)/10 = (2321)/10 = 232.现在，10000需要减少2倍。现在来看看 Java 代码。

private static boolean isPalindrome(int n) {
if (n < 0)
return false;


int div = 1;
// find the divisor
while (n / div >= 10)
div *= 10;


// any number less than 10 is a palindrome
while (n != 0) {
int leading = n / div;
int trailing = n % 10;
if (leading != trailing)
return false;


// % with div gets rid of leading digit
// dividing result by 10 gets rid of trailing digit
n = (n % div) / 10;


// got rid of 2 numbers, update div accordingly
div /= 100;
}
return true;
}

根据哈迪克的建议进行编辑，以涵盖数字中有零的情况。

小开

一行 python 代码:

def isPalindrome(number):
return True if str(number) == ''.join(reversed(str(number))) else False

小开

假设前导零被忽略，下面是一个实现:

#include<bits/stdc++.h>
using namespace std;
vector<int>digits;
stack<int>digitsRev;
int d,number;
bool isPal=1;//initially assuming the number is palindrome
int main()
{
cin>>number;
if(number<10)//if it is a single digit number than it is palindrome
{
cout<<"PALINDROME"<<endl;
return 0;
}
//if the number is greater than or equal to 10
while(1)
{
d=number%10;//taking each digit
number=number/10;
//vector and stack will pick the digits
//in reverse order to each other
digits.push_back(d);
digitsRev.push(d);
if(number==0)break;
}
int index=0;
while(!digitsRev.empty())
{
//Checking each element of the vector and the stack
//to see if there is any inequality.
//And which is equivalent to check each digit of the main
//number from both sides
if(digitsRev.top()!=digits[index++])
{
cout<<"NOT PALINDROME"<<endl;
isPal=0;
break;
}
digitsRev.pop();
}
//If the digits are equal from both sides than the number is palindrome
if(isPal==1)cout<<"PALINDROME"<<endl;
}

小开

在 java 中检查这个解决方案:

private static boolean ispalidrome(long n) {
return getrev(n, 0L) == n;
}


private static long getrev(long n, long initvalue) {
if (n <= 0) {
return initvalue;
}
initvalue = (initvalue * 10) + (n % 10);
return getrev(n / 10, initvalue);
}

小开

只需通过 Math 函数获取数字的数字计数，然后使用’/’和’%’操作进行迭代，如下所示。在 x = (x% 除法器)/10之后，我们应该除以100，因为我们做了2个零运算。

public static boolean isPalindrome(int x) {
if (x < 0) return false;
if (x < 10) return true;


int numDigits = (int)(Math.log10(x)+1);
int divider = (int) (Math.pow(10, numDigits - 1));
for (int i = 0; i < numDigits / 2; i++) {
if (x / divider != x % 10)
return false;
x = (x % divider) / 10;
divider /= 100;
}
return true;
}

小开

就我个人而言，我是这样做的，没有重叠; 代码停止检查匹配字符在正确的位置是否有一个偶数或奇数长度的字符串。上面提到的一些其他方法将尝试在不需要的时候匹配一个额外的时间。

如果我们使用 length/2，它仍然可以工作，但是它会做一个额外的检查，这是它不需要做的。例如，“ pop”的长度是3。3/2 = 1.5，所以当 i = 2时它将停止检查(因为1 < 1.5，所以当 i = 1时它也将停止检查) ，但是我们需要它停止在0，而不是1。第一个“ p”位于位置0，它将自我检查长度1-0(当前位置) ，这是位置2中的最后一个“ p”，然后我们留下了不需要检查的中心字母。当我们处理 length/2时，我们在1处停止，所以执行额外的检查时，i 位于1位置(“ o”) ，并将其与自身(length-1-i)进行比较。

// Checks if our string is palindromic.
var ourString = "A Man, /.,.()^&*A Plan, A Canal__-Panama!";
isPalin(ourString);


function isPalin(string) {
// Make all lower case for case insensitivity and replace all spaces, underscores and non-words.
string = string.toLowerCase().replace(/\s+/g, "").replace(/\W/g,"").replace(/_/g,"");
for(i=0; i<=Math.floor(string.length/2-1); i++) {
if(string[i] !== string[string.length-1-i]) {
console.log("Your string is not palindromic!");
break;
} else if(i === Math.floor(string.length/2-1)) {
console.log("Your string is palindromic!");
}
}
}

Https://repl.it/fnvz/1

小开

这是我的 Java 代码。基本上就是比较字符串的第一个和最后一个值和下一个内部值对等等。

    /*Palindrome number*/
String sNumber = "12321";
int l = sNumber.length(); // getting the length of sNumber. In this case its 5
boolean flag = true;
for (int i = 0; i <= l; ++i) {
if (sNumber.charAt(i) != sNumber.charAt((l--) -1)) { //comparing the first and the last values of the string
System.out.println(sNumber +" is not a palindrome number");
flag = false;
break;
}
//l--; // to reducing the length value by 1
}
if (flag) {
System.out.println(sNumber +" is a palindrome number");
}

小开

该死，我疯了！ Http://www.palindromelist.net/palindromes-d/
单步示例: 332是回文数吗？

n = 332
q = n / 10 = 33
r = n - 10 * q = 2
r > 0
r != q
n = q = 33
n > r
q = n / 10 = 3
r -= q = 4294967295
r *= 10 = 4294967286
r += n = 23
r != n
r != q
n = q = 3
n > r ? No, so 332 isn't a palindromic number.

溢出也不是问题。有两个部分是必要的，在代码(C #)中，它们是用乘法完成的。一个 n 位数字: ~ n/2除法！

const ulong c0 = 0xcccccccdUL;
static bool isPal(uint n)
{
if (n < 10) return true;
uint q = (uint)(c0 * n >> 35);
uint r = n - 10 * q;
if (r == 0) return false;
if (r == q) return true;
n = q;
while (n > r)
{
q = (uint)(c0 * n >> 35);
r -= q;
r *= 10;
r += n;
if (r == n || r == q) return true;
n = q;
}
return false;
}

有142948个回文数 < 2 ^ 32，它们的总和是137275874705916。

using System;
class Program
{
static void Main()  // take a break
{
uint n, c; var sw = System.Diagnostics.Stopwatch.StartNew();
n = ~0u; c = 0; sw.Restart(); while (n > 0) if (isPal0(n--)) c++;
Console.WriteLine(sw.Elapsed + " " + c);                  // 76 s
n = ~0u; c = 0; sw.Restart(); while (n > 0) if (isPal1(n--)) c++;
Console.WriteLine(sw.Elapsed + " " + c);                  // 42 s
n = ~0u; c = 0; sw.Restart(); while (n > 0) if (isPal2(n--)) c++;
Console.WriteLine(sw.Elapsed + " " + c);                  // 31 s
Console.Read();
}


static bool isPal0(uint u)
{
uint n = u, rev = 0;
while (n > 0) { uint dig = n % 10; rev = rev * 10 + dig; n /= 10; }
return u == rev;
}


static bool isPal1(uint u)
{
uint n = u, r = 0;
while (n >= 10) r = n + (r - (n /= 10)) * 10;
return u == 10 * r + n;
}


static bool isPal2(uint n)
{
if (n < 10) return true;
uint q = n / 10, r = n - 10 * q;
if (r == 0 || r == q) return r > 0;
while ((n = q) > r)
{
q /= 10; r -= q; r *= 10; r += n;
if (r == n || r == q) return true;
}
return false;
}
}

这个似乎更快。

using System;
class Program
{
static void Main()
{
uint n, c; var sw = System.Diagnostics.Stopwatch.StartNew();
n = ~0u; c = 0; sw.Restart(); while (n > 0) if (isPal(n--)) c++;
Console.WriteLine(sw.Elapsed + " " + c);                 // 21 s
Console.Read();
}


static bool isPal(uint n)
{
return n < 100 ? n < 10 || n % 11 == 0 :
n < 1000 ? /*          */ n / 100 == n % 10 :
n < 10000 ? n % 11 == 0 && n / 1000 == n % 10 && isP(n) :
n < 100000 ? /*          */ n / 10000 == n % 10 && isP(n) :
n < 1000000 ? n % 11 == 0 && n / 100000 == n % 10 && isP(n) :
n < 10000000 ? /*          */ n / 1000000 == n % 10 && isP(n) :
n < 100000000 ? n % 11 == 0 && n / 10000000 == n % 10 && isP(n) :
n < 1000000000 ? /*          */ n / 100000000 == n % 10 && isP(n) :
n % 11 == 0 && n / 1000000000 == n % 10 && isP(n);
}


static bool isP(uint n)
{
uint q = n / 10, r = n - 10 * q;
do { n = q; q /= 10; r -= q; r *= 10; r += n; } while (r < q);
return r == q || r == n;
}
}

用一个几乎平衡的二叉搜索意大利面条树。

using System;
class Program
{
static void Main()
{
uint n, c; var sw = System.Diagnostics.Stopwatch.StartNew();
n = c = 0; sw.Restart(); while (n < ~0u) if (isPal(n++)) c++;
Console.WriteLine(sw.Elapsed + " " + c);              // 17 s
Console.Read();
}


static bool isPal(uint n)
{
return n < 1000000 ? n < 10000 ? n < 1000 ? n < 100 ?
n < 10 || n % 11 == 0 : n / 100 == n % 10 :
n / 1000 == n % 10 && isP(n) : n < 100000 ?
n / 10000 == n % 10 && isP(n) :
n / 100000 == n % 10 && isP(n) :
n < 100000000 ? n < 10000000 ?
n / 1000000 == n % 10 && isP(n) :
n % 11 == 0 && n / 10000000 == n % 10 && isP(n) :
n < 1000000000 ? n / 100000000 == n % 10 && isP(n) :
n % 11 == 0 && n / 1000000000 == n % 10 && isP(n);
}


static bool isP(uint n)
{
uint q = n / 10, r = n - 10 * q;
do { n = q; q /= 10; r -= q; r *= 10; r += n; } while (r < q);
return r == q || r == n;
}
}

上下颠倒。

using System;
class Program
{
static void Main()
{
uint n, c; var sw = System.Diagnostics.Stopwatch.StartNew();
n = c = 0; sw.Restart(); while (n < ~0u) if (isPal(n++)) c++;
Console.WriteLine(sw.Elapsed + " " + c);              // 16 s
Console.Read();
}


static bool isPal(uint n)
{
return
n > 999999999 ? n % 11 == 0 && n / 1000000000 == n % 10 && isP(n) :
n > 99999999 ? n / 100000000 == n % 10 && isP(n) :
n > 9999999 ? n % 11 == 0 && n / 10000000 == n % 10 && isP(n) :
n > 999999 ? n / 1000000 == n % 10 && isP(n) :
n > 99999 ? n % 11 == 0 && n / 100000 == n % 10 && isP(n) :
n > 9999 ? n / 10000 == n % 10 && isP(n) :
n > 999 ? n % 11 == 0 && n / 1000 == n % 10 && isP(n) :
n > 99 ? n / 100 == n % 10 :
n < 10 || n % 11 == 0;
}


static bool isP(uint n)
{
uint q = n / 10, r = n - 10 * q;
do { n = q; q /= 10; r -= q; r *= 10; r += n; } while (r < q);
return r == q || r == n;
}
}

小开

下面是迅速的答案。它从左边和右边读取数字，并比较它们是否相同。这样做，我们将永远不会面临整数溢出 < em > (逆序数法可能出现的情况) 的问题，因为我们没有创建另一个数字。

步骤:

得到数字的长度
循环长度 + 1(第一个)—— > 0
得到数字，得到最后一个数字
如果两个数字不相等，返回 false，因为数字不是回文
我..
从 num 中丢弃最后一个数字(num = num/10)

厕所结束返回真

func isPalindrom(_ input: Int) -> Bool {
if input < 0 {
return false
}


if input < 10 {
return true
}


var num = input
let length = Int(log10(Float(input))) + 1
var i = length


while i > 0 && num > 0 {


let ithDigit = (input / Int(pow(10.0, Double(i) - 1.0)) ) % 10
let r = Int(num % 10)


if ithDigit != r {
return false
}


num = num / 10
i -= 1
}


return true
}

小开

public static boolean isPalindrome(int x) {
int newX = x;
int newNum = 0;
boolean result = false;
if (x >= 0) {
while (newX >= 10) {
newNum = newNum+newX % 10;
newNum = newNum * 10;
newX = newX / 10;
}
newNum += newX;


if(newNum==x) {
result = true;
}
else {
result=false;
}
}


else {


result = false;
}
return result;
}

小开

这个解决方案非常有效，因为我使用的是 StringBuilder，这意味着 StringBuilder 类实现为一个可变的字符序列。这意味着要将新的 String 或字符追加到 StringBuilder 中。

 public static boolean isPal(String ss){
StringBuilder stringBuilder = new StringBuilder(ss);
stringBuilder.reverse();
return ss.equals(stringBuilder.toString());
}

小开

public boolean isPalindrome(int x) {
if (isNegative(x))
return false;


boolean isPalindrome = reverseNumber(x) == x ? true : false;
return isPalindrome;
}


private boolean isNegative(int x) {
if (x < 0)
return true;
return false;
}


public int reverseNumber(int x) {


int reverseNumber = 0;


while (x > 0) {
int remainder = x % 10;
reverseNumber = reverseNumber * 10 + remainder;
x = x / 10;
}


return reverseNumber;
}

小开

我认为这里提供的最佳解决方案是 https://stackoverflow.com/a/199203/5704551

这个解决方案的编码实现可以是这样的:

var palindromCheck(nums) = () => {
let str = x.toString()
// + before str is quick syntax to cast String To Number.
return nums === +str.split("").reverse().join("")
}