blocks|key|1502771|text|这是one+of+the+Project+Euler+problems。当我在Haskell中解决这个问题时，我完全按照你的建议做了，把数字转换成字符串。然后，很容易就可以检查字符串是不是一个Pallindrom型字符串。如果它表现得足够好，那么为什么还要费心让它变得更复杂呢？作为一个pallindrome是一种词汇属性，而不是数学属性。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1502772|entityMap|0|LINK|mutability|MUTABLE|url|http://projecteuler.net/index.php?section=problems&id=4^0|2|X|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

This is <a href="http://projecteuler.net/index.php?section=problems&amp;id=4" rel="noreferrer">one of the Project Euler problems</a>. When I solved it in Haskell I did exactly what you suggest, convert the number to a String. It's then trivial to check that the string is a pallindrome. If it performs well enough, then why bother making it more complex? Being a pallindrome is a lexical property rather than a mathematical one.

blocks|key|1718037|text|对于任何给定的数字：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718038|n+=+num;
rev+=+0;
while+(num+>+0)
{
++++dig+=+num+%25+10;
++++rev+=+rev+*+10+%2B+dig;
++++num+=+num+/+10;
}|code-block|syntax|javascript|1718039|如果为n+==+rev，则num为回文：|offset|length|style|CODE|1718040|cout+<<+"Number+"+<<+(n+==+rev+?+"IS"+:+"IS+NOT")+<<+"+a+palindrome"+<<+endl;|1718041|entityMap^0|0|0|3|8|D|3|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

For any given number:

<pre class="lang-cpp prettyprint-override"><code>n = num;
rev = 0;
while (num &gt; 0)
{
 dig = num % 10;
 rev = rev * 10 + dig;
 num = num / 10;
}
</code></pre>

If <code>n == rev</code> then <code>num</code> is a palindrome:

<pre class="lang-cpp prettyprint-override"><code>cout &lt;&lt; "Number " &lt;&lt; (n == rev ? "IS" : "IS NOT") &lt;&lt; " a palindrome" &lt;&lt; endl;
</code></pre>

blocks|key|1718106|text|def+ReverseNumber(n,+partial=0):
++++if+n+==+0:
++++++++return+partial
++++return+ReverseNumber(n+//+10,+partial+*+10+%2B+n+%25+10)

trial+=+123454321
if+ReverseNumber(trial)+==+trial:
++++print("It's+a+Palindrome!")|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1718107|仅适用于整数。从问题陈述中并不清楚是否需要考虑浮点数或前导零。|unstyled|1718108|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre class="lang-py prettyprint-override"><code>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!")
</code></pre>

Works for integers only. It's unclear from the problem statement if floating point numbers or leading zeros need to be considered.

blocks|key|1718714|text|上面的大多数答案都有一个微不足道的问题，那就是int变量可能会溢出。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718715|请参阅http://articles.leetcode.com/palindrome-number/|offset|length|1718716|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+%25+10;
++++++++if+(l+!=+r)
++++++++++++return+false;
++++++++x+=+(x+%25+div)+/+10;
++++++++div+/=+100;
++++}
++++return+true;
}|code-block|syntax|javascript|1718717|entityMap|0|LINK|mutability|MUTABLE|url|https://web.archive.org/web/20180222083908/http://articles.leetcode.com/palindrome-number/^0|0|3|1B|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@$D|U|E|V|1|W]]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Above most of the answers having a trivial problem is that the int variable possibly might overflow.

Refer to <a href="https://web.archive.org/web/20180222083908/http://articles.leetcode.com/palindrome-number/" rel="nofollow noreferrer">http://articles.leetcode.com/palindrome-number/</a>

<pre class="lang-java prettyprint-override"><code>boolean isPalindrome(int x) {
 if (x &lt; 0)
 return false;
 int div = 1;
 while (x / div &gt;= 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;
}
</code></pre>

blocks|key|1502986|text|int+is_palindrome(unsigned+long+orig)
{
++++unsigned+long+reversed+=+0,+n+=+orig;

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

++++return+orig+==+reversed;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1502987|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre class="lang-c prettyprint-override"><code>int is_palindrome(unsigned long orig)
{
 unsigned long reversed = 0, n = orig;

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

 return orig == reversed;
}
</code></pre>

blocks|key|1502821|text|将每个单独的数字推入堆栈，然后将它们弹出。如果它是相同的向前和向后，这是一个回文。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1502822|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Push each individual digit onto a stack, then pop them off. If it's the same forwards and back, it's a palindrome.

blocks|key|1719398|text|据我所知最快的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1719399|bool+is_pal(int+n)+{
++++if+(n+%25+10+==+0)+return+0;
++++int+r+=+0;
++++while+(r+<+n)+{
++++++++r+=+10+*+r+%2B+n+%25+10;
++++++++n+/=+10;
++++}
++++return+n+==+r+%7C%7C+n+==+r+/+10;
}|code-block|syntax|javascript|1719400|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Fastest way I know:

<pre class="lang-c prettyprint-override"><code>bool is_pal(int n) {
 if (n % 10 == 0) return 0;
 int r = 0;
 while (r &lt; n) {
 r = 10 * r + n % 10;
 n /= 10;
 }
 return n == r || n == r / 10;
}
</code></pre>

blocks|key|1719362|text|在Python中，有一种快速、迭代的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1719363|def+reverse(n):
++++newnum=0
++++while+n>0:
++++++++newnum+=+newnum*10+%2B+n+%25+10
++++++++n//=10
++++return+newnum

def+palindrome(n):
++++return+n+==+reverse(n)|code-block|syntax|javascript|1719364|这也防止了递归的内存问题(就像Java中的StackOverflow错误)。|1719365|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

In Python, there is a fast, iterative way.

<pre class="lang-py prettyprint-override"><code>def reverse(n):
 newnum=0
 while n&gt;0:
 newnum = newnum*10 + n % 10
 n//=10
 return newnum

def palindrome(n):
 return n == reverse(n)
</code></pre>

This also prevents memory issues with recursion (like StackOverflow error in Java)

blocks|key|1503227|text|只是为了好玩，这个也可以用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1503228|a+=+num;
b+=+0;
if+(a+%25+10+==+0)
++return+a+==+0;
do+{
++b+=+10+*+b+%2B+a+%25+10;
++if+(a+==+b)
++++return+true;
++a+=+a+/+10;
}+while+(a+>+b);
return+a+==+b;|code-block|syntax|javascript|1503229|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Just for fun, this one also works.

<pre class="lang-c prettyprint-override"><code>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 &gt; b);
return a == b;
</code></pre>

blocks|key|1503154|text|我用一种非常粗暴的方式回答了Euler问题。很自然地，当我到达新的未锁定的相关论坛线程时，有一个更智能的算法在展示。也就是说，一个被称为贝格纳的成员有一个如此新颖的方法，以至于我决定使用他的算法重新实现我的解决方案。他的版本是Python+(使用嵌套循环)，我用Clojure重新实现了它(使用单循环/递归)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1503155|这里是供你娱乐的：|1503156|(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)))|code-block|syntax|javascript|1503157|也有一些常见的Lisp答案，但我不理解它们。|1503158|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I answered the Euler problem using a very brute-forcy way. Naturally, there was a much smarter algorithm at display when I got to the new unlocked associated forum thread. Namely, a member who went by the handle Begoner had such a novel approach, that I decided to reimplement my solution using his algorithm. His version was in Python (using nested loops) and I reimplemented it in Clojure (using a single loop/recur).

Here for your amusement:

<pre class="lang-clj prettyprint-override"><code>(defn palindrome? [n]
 (let [len (count n)]
 (and
 (= (first n) (last n))
 (or (&gt;= 1 (count n))
 (palindrome? (. n (substring 1 (dec len))))))))

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

(time (prn (begoners-palindrome)))
</code></pre>

There were Common Lisp answers as well, but they were ungrokable to me.

blocks|key|1503293|text|这里是一个Scheme版本，它构造了一个函数，可以在任何基础上工作。它具有冗余校验:如果数字是基数的倍数(以0结尾)，则快速返回false。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1503294|而且它不会重建整个反转的数字，只有一半。|1503295|这就是我们所需要的。|1503296|(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+(%2B+(*+base+t)+m))))))))))
++++++++++++(Q+n+0)))))))|code-block|syntax|javascript|1503297|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is an Scheme version that constructs a function that will work against any base. It has a redundancy check: return false quickly if the number is a multiple of the base (ends in 0). 
And it doesn't rebuild the entire reversed number, only half. 
That's all we need.

<pre class="lang-lisp prettyprint-override"><code>(define make-palindrome-tester
 (lambda (base)
 (lambda (n)
 (cond
 ((= 0 (modulo n base)) #f)
 (else
 (letrec
 ((Q (lambda (h t)
 (cond
 ((&lt; 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)))))))
</code></pre>

blocks|key|1504602|text|ruby中的递归解决方案，不需要将数字转换为字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1504603|def+palindrome?(x,+a=x,+b=0)
++return+x==b+if+a<1
++palindrome?(x,+a/10,+b*10+%2B+a%2510)
end

palindrome?(55655)|code-block|syntax|javascript|1504604|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Recursive solution in ruby, without converting the number to string.

<pre class="lang-rb prettyprint-override"><code>def palindrome?(x, a=x, b=0)
 return x==b if a&lt;1
 palindrome?(x, a/10, b*10 + a%10)
end

palindrome?(55655)
</code></pre>

blocks|key|1719293|text|Golang版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1719294|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+%2B+n%2510
++++++++++++n+=+n+/+10
++++++++}+else+{
++++++++++++break
++++++++}
++++}
++++return+r
}|code-block|syntax|javascript|1719295|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Golang version:

<pre class="lang-golang prettyprint-override"><code>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 &gt; 0 {
 r = r*10 + n%10
 n = n / 10
 } else {
 break
 }
 }
 return r
}
</code></pre>

blocks|key|1718192|text|弹出第一个和最后一个数字，并将它们进行比较，直到用完。可能有一个数字留下，也可能没有，但无论哪种方式，如果所有弹出的数字都匹配，它是一个回文。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718193|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Pop off the first and last digits and compare them until you run out. There may be a digit left, or not, but either way, if all the popped off digits match, it is a palindrome.

blocks|key|1719000|text|这是另一个使用模板的c%2B%2B解决方案。此解决方案适用于不区分大小写的回文字符串比较。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1719001|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%2B%2B;
++++}
++++return+true;
}|code-block|syntax|javascript|1719002|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is one more solution in c++ using templates . This solution will work for case insensitive palindrome string comparison .

<pre class="lang-cpp prettyprint-override"><code>template &lt;typename bidirection_iter&gt;
bool palindrome(bidirection_iter first, bidirection_iter last)
{
 while(first != last &amp;&amp; first != --last)
 {
 if(::toupper(*first) != ::toupper(*last))
 return false;
 else
 first++;
 }
 return true;
}
</code></pre>

blocks|key|1718472|text|一种比@sminks方法更好的常量因子方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718473|num=n
lastDigit=0;
rev=0;
while+(num>rev)+{
++++lastDigit=num%2510;
++++rev=rev*10%2BlastDigit;
++++num+/=2;
}
if+(num==rev)+print+PALINDROME;+exit(0);
num=num*10%2BlastDigit;+//+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|code-block|syntax|javascript|1718474|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

a method with a little better constant factor than @sminks method:

<pre><code>num=n
lastDigit=0;
rev=0;
while (num&gt;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
</code></pre>

blocks|key|1718499|text|这是一个f#版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718500|let+reverseNumber+n+=
++++let+rec+loop+acc+=+function
++++%7C0+->+acc
++++%7Cx+->+loop+(acc+*+10+%2B+x+%25+10)+(x/10)++++
++++loop+0+n

let+isPalindrome+=+function
++++%7C+x++when+x+=+reverseNumber+x+->+true
++++%7C+_+->+false|code-block|syntax|javascript|1718501|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

here's a f# version:

<pre><code>let reverseNumber n =
 let rec loop acc = function
 |0 -&gt; acc
 |x -&gt; loop (acc * 10 + x % 10) (x/10) 
 loop 0 n

let isPalindrome = function
 | x when x = reverseNumber x -&gt; true
 | _ -&gt; false
</code></pre>

blocks|key|1718525|text|如果一个数字的字符串表示是回文的，那么它就是回文的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718526|def+is_palindrome(s):
++++return+all(s[i]+==+s[-(i+%2B+1)]+for+i+in+range(len(s)//2))

def+number_palindrome(n):
++++return+is_palindrome(str(n))|code-block|syntax|javascript|1718527|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A number is palindromic if its string representation is palindromic:

<pre><code>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))
</code></pre>

blocks|key|1503445|text|def+palindrome(n):
++++d+=+[]
++++while+(n+>+0):
++++++++d.append(n+%25+10)
++++++++n+//=+10
++++for+i+in+range(len(d)/2):
++++++++if+(d[i]+!=+d[-(i%2B1)]):
++++++++++++return+"Fail."
++++return+"Pass."|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1503446|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

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

blocks|key|1718953|text|检查给定的数字是否为回文(Java代码)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718954|class+CheckPalindrome{
public+static+void+main(String+str[]){
++++++++int+a=242,+n=a,+b=a,+rev=0;
++++++++while(n>0){
++++++++++++++++++++a=n%2510;++n=n/10;rev=rev*10%2Ba;
++++++++++++++++++++System.out.println(a%2B"++"%2Bn%2B"++"%2Brev);++//+to+see+the+logic
+++++++++++++++}
++++++++if(rev==b)++System.out.println("Palindrome");
++++++++else++++++++System.out.println("Not+Palindrome");
++++}
}|code-block|syntax|javascript|1718955|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

To check the given number is Palindrome or not (Java Code)

<pre><code>class CheckPalindrome{
public static void main(String str[]){
 int a=242, n=a, b=a, rev=0;
 while(n&gt;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");
 }
}
</code></pre>

blocks|key|1719105|text|这里发布的许多解决方案都颠倒了整数，并将其存储在一个变量中，该变量使用了额外的空间，即O(n)，但这里是一个使用O(1)空间的解决方案。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1719106|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+%25+10
++++++++left+=+num+/+10**length
++++++++if+right+!=+left:
++++++++++++return+False
++++++++num+%25=+10**length
++++++++num+/=+10
++++++++length+-=+2
++++return+True|code-block|syntax|javascript|1719107|entityMap^0|17|4|1K|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

A lot of the solutions posted here reverses the integer and stores it in a variable which uses extra space which is <code>O(n)</code>, but here is a solution with <code>O(1)</code> space.

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

blocks|key|1719158|text|我总是使用这个python解决方案，因为它很紧凑。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1719159|def+isPalindrome(number):
++++return+int(str(number)[::-1])==number|code-block|syntax|javascript|1719160|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I always use this python solution due to its compactness.

<pre><code>def isPalindrome(number):
 return int(str(number)[::-1])==number
</code></pre>

blocks|key|1718554|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718555|reverse+=+0;
++++remainder+=+0;
++++count+=+0;
++++while+(number+>+reverse)
++++{
++++++++remainder+=+number+%25+10;
++++++++reverse+=+reverse+*+10+%2B+remainder;
++++++++number+=+number+/+10;
++++++++count%2B%2B;
++++}
++++Console.WriteLine(count);
++++if+(reverse+==+number)
++++{
++++++++Console.WriteLine("Your+number+is+a+palindrome");
++++}
++++else
++++{
++++++++number+=+number+*+10+%2B+remainder;
++++++++if+(reverse+==+number)
++++++++++++Console.WriteLine("your+number+is+a+palindrome");
++++++++else
++++++++++++Console.WriteLine("your+number+is+not+a+palindrome");
++++}
++++Console.ReadLine();
}
}|code-block|syntax|javascript|1718556|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try this:

<pre><code>reverse = 0;
 remainder = 0;
 count = 0;
 while (number &gt; 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();
}
}
</code></pre>

blocks|key|1503519|text|下面是一个在python中使用列表作为堆栈的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1503520|def+isPalindromicNum(n):
++++"""
++++++++is+'n'+a+palindromic+number?
++++"""
++++ns+=+list(str(n))
++++for+n+in+ns:
++++++++if+n+!=+ns.pop():
++++++++++++return+False
++++return+True|code-block|syntax|javascript|1503521|弹出堆栈仅考虑数字的最右侧以进行比较，因此无法快速减少检查|1503522|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here is a solution usings lists as stacks in python : 

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

popping the stack only considers the rightmost side of the number for comparison and it fails fast to reduce checks

blocks|key|1503545|text|+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%2510;

++++++++++//To+store+it+in+reverse
++++++++++rev=(rev*10)%2Bdigit;

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

++++++//To+check+if+a+number+is+palindrome+or+not
++++++if(rev==givenNum)
++++++{+
+++++++++System.out.println(givenNum%2B"is+a+palindrome+");
++++++}
++++++else
++++++{
+++++++++System.out.pritnln(givenNum%2B"is+not+a+palindrome");
++++++}
++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1503546|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

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

 while(n&gt;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");
 }
 }
}
</code></pre>

blocks|key|1503591|text|let+isPalindrome+(n:int)+=
+++let+l1+=+n.ToString()+%7C>+List.ofSeq+%7C>+List.rev
+++let+rec+isPalindromeInt+l1+l2+=
+++++++match+(l1,l2)+with
+++++++%7C+(h1::rest1,h2::rest2)+->+if+(h1+=+h2)+then+isPalindromeInt+rest1+rest2+else+false
+++++++%7C+_+->+true
+++isPalindromeInt+l1+(n.ToString()+%7C>+List.ofSeq)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1503592|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

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

blocks|key|1718758|text|checkPalindrome(int+number)
{
++++int+lsd,+msd,len;
++++len+=+log10(number);
++++while(number)
++++{
++++++++msd+=+(number/pow(10,len));+//+"most+significant+digit"
++++++++lsd+=+number%2510;+//+"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;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1718759|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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;
}
</code></pre>

blocks|key|1718793|text|递归方式，效率不是很高，只提供一个选项|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718794|(Python代码)|1718795|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%2510:
++++++++++++return+False
++++++++#+shrink+the+size,+num+and+denominator
++++++++num+%25=+demoninator
++++++++num+/=+10
++++++++size+-=+2
++++++++demoninator+/=100
++++++++return+isPalindromeHelper(num,+size,+demoninator)+|code-block|syntax|javascript|1718796|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Recursive way, not very efficient, just provide an option

(Python code)

<pre><code>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 &lt;=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) 
</code></pre>

blocks|key|1718867|text|似乎最简单的事情是找到相反的数字并比较这两个数字：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718868|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%2B%2B)
++++{
++++++++num+=+num/10;
++++}

++++System.out.println("this+number+has+"%2Bi%2B"+digits");

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



++++num+=+max;

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


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

++++System.out.println("and+the+number+backwards+is+"%2Bopos);

++++if+(opos+==+max+)
++++{
++++++++System.out.println("palindrome!!");
++++}
++++else
++++{
++++++++System.out.println("aint+no+palindrome!");
++++}|code-block|syntax|javascript|1718869|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

it seems like the easest thing would be to find the opposit number and compare the two:

<pre><code>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&gt;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&lt;size;i++)
 {
 nsize *=10;
 }


 while(num&gt;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!");
 }
</code></pre>

blocks|key|1718900|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718901|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+%25+10+%2B+a+*+10++++
++++++++m+=+m+/+10++++

++++if(+n+==+a):++++
++++++++print('%25d+is+a+palindrome+number'+%25n)
++++else:
++++++++print('%25d+is+not+a+palindrome+number'+%25n)|code-block|syntax|javascript|1718902|只需回调函数|1718903|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Try this: 

<pre><code>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)
</code></pre>

just call back the functions

blocks|key|1503912|text|这是一种方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1503913|class+Palindrome_Number{
++++void+display(int+a){
++++++++int+count=0;
++++++++int+n=a;
++++++++int+n1=a;
++++++++while(a>0){
++++++++++++count%2B%2B;
++++++++++++a=a/10;
++++++++}
++++++++double+b=0.0d;
++++++++while(n>0){
++++++++++++b%2B=(n%2510)*(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");++++++++++++
++++++++}
++++}
}|code-block|syntax|javascript|1503914|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a way.

<pre><code>class Palindrome_Number{
 void display(int a){
 int count=0;
 int n=a;
 int n1=a;
 while(a&gt;0){
 count++;
 a=a/10;
 }
 double b=0.0d;
 while(n&gt;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"); 
 }
 }
}
</code></pre>

blocks|key|1719063|text|我使用常规的方法，将数字转换为字符串，然后将字符串进一步转换为charArray。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1719064|遍历charArray并查找位置处的数字是否相等。|1719065|注意-：不反转字符串。|1719066|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%2B%2B)
++++{
++++++++if+(arr[i]+==+arr[len+-+1])
++++++++{
++++++++++++if+(i+>=+len)
++++++++++++{
++++++++++++++++return+true;
++++++++++++}
++++++++++++len--;
++++++++}
++++++++else
++++++++{
++++++++++++break;
++++++++}
++++}
++++return+false;
}|code-block|syntax|javascript|1719067|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I went with the regular approach by converting number to string and then further converting string to charArray. 
Traversing through charArray and find if number at positions are equal or not. 
Note-: Not reversing the string.
<pre><code>public bool IsPalindrome(int num)
{
 string st = num.ToString();
 char[] arr = st.ToCharArray();
 int len = arr.Length;
 if (len &lt;= 1)
 {
 return false;
 }
 for (int i = 0; i &lt; arr.Length; i++)
 {
 if (arr[i] == arr[len - 1])
 {
 if (i &gt;= len)
 {
 return true;
 }
 len--;
 }
 else
 {
 break;
 }
 }
 return false;
}
</code></pre>

blocks|key|1504179|text|int+reverse(int+num)
{
++++assert(num+>=+0);+++//+for+non-negative+integers+only.
++++int+rev+=+0;
++++while+(num+!=+0)
++++{
++++++++rev+=+rev+*+10+%2B+num+%25+10;
++++++++num+/=+10;
++++}
++++return+rev;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1504180|这似乎也是有效的，但你有没有考虑到反转的数字可能会溢出？如果它溢出，则行为是特定于语言的(对于Java，数字在溢出时环绕，但在C/C%2B%2B中，它的行为是未定义的)。糟透了。|unstyled|1504181|事实证明，从两端进行比较更容易。首先，比较第一个和最后一个数字。如果它们不相同，则不能是回文。如果它们是相同的，从两端切下一个数字，然后继续，直到你没有留下数字，你得出的结论是它一定是一个回文。|1504182|现在，获取并切碎最后一个数字很容易。然而，以一种通用的方式获取和截取第一个数字需要一些思考。下面的解决方案可以解决这个问题。|1504183|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+%25+10;
++++++++if+(l+!=+r)
++++++++++++return+0;
++++++++x+=+(x+%25+div)+/+10;
++++++++div+/=+100;
++++}
++++return+1;
}|1504184|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|M|3|-4|5|F|7|T|8|@]|9|@]|A|$]]]|N|$]]

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

This seemed to work too, but did you consider the possibility that the reversed number might overflow? If it overflows, the behavior is language specific (For Java the number wraps around on overflow, but in C/C++ its behavior is undefined). Yuck.

It turns out that comparing from the two ends is easier. First, compare the first and last digit. If they are not the same, it must not be a palindrome. If they are the same, chop off one digit from both ends and continue until you have no digits left, which you conclude that it must be a palindrome.

Now, getting and chopping the last digit is easy. However, getting and chopping the first digit in a generic way requires some thought. The solution below takes care of it.

<pre><code>int isIntPalindrome(int x)
{
 if (x &lt; 0)
 return 0;
 int div = 1;
 while (x / div &gt;= 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;
}
</code></pre>

blocks|key|1719476|text|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"|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1719477|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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"
</code></pre>

blocks|key|1719591|text|我不确定这是不是最好的答案，而且我还是个编程新手。(用java写的)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1719592|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%2B%2B)+{
++++++++++++arrPalin[i]+=+String.valueOf(randInt.nextInt(2147483646)+%2B+1);
++++++++++++System.out.println(arrPalin[i]);
++++++++}

++++++++final+long+startTime+=+System.nanoTime();

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

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

++++++++for+(int+i+=+0;+i+<+t;+i%2B%2B)+{
++++++++++++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%2B%2B)+{
++++++++++++if+((i%252)+==+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%2B%2B;
++++++++}

++++++++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%2B%2B)+{
++++++++++++if+(i+!=+0)+{
++++++++++++++++if+((i+%25+2)+==+0)+{
++++++++++++++++++++chars[i]+=+N.charAt(i);
++++++++++++++++}+else+if+((i+%25+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+%25+2)+==+0)+{
++++++++++++numOne+=+N.charAt(length-1);
++++++++++++numTwo+=+N.charAt(length-2);
++++++++++++newN[length-1]+=+(char)(numOne%2B1);
++++++++++++newN[length-2]+=+(char)(numTwo%2B1);
++++++++++++returnVal+=+String.valueOf(newN);
++++++++}+else+{
++++++++++++numOne+=+N.charAt(length-1);
++++++++++++newN[length-1]+=+(char)(numOne%2B1);
++++++++++++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%2B%2B)+{
++++++++++++++++if+(((i+%25+2)+==+0)+&&+(i+!=+0))+{+//+for+i+>+0,+even
++++++++++++++++++++newN[i+/+2]+=+N.charAt(i);
++++++++++++++++}+else+if+((i+%25+2)+==+0+&&+(i+==+0))+{+//+for+i+=+0
++++++++++++++++++++newN[0]+=+N.charAt(0);
++++++++++++++++}
++++++++++++}
++++++++for+(int+i+=+(length/2);+i+<+length;+i%2B%2B)+{
++++++++++++newN[i]+=+newN[Math.abs(i+-+(length+-+1))];
++++++++}

++++++++return+String.valueOf(newN);
++++}


}|code-block|syntax|javascript|1719593|所以对于这个代码，输入一个数字(我做了我想要的随机数字)，它会转换，例如输入是172345到157423。然后它会将其更改为117722，如果偶数变为117733，如果奇数只对最后一位数字执行相同的操作。那就变成173371吧。它并不是专门寻找一个回文数，而是寻找下一个最高的回文数。|1719594|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Not sure if this is the best answer, and I'm new at programming. (it's in java)

<pre><code>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 &lt; 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 &lt; t; i++) {
 nextPalin[i] = (unmatcher(incrementer(switcher(match(arrPalin[i])))));
 }

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

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

 return String.valueOf(newN);
 }


}
</code></pre>

So for this code, input a number (I did random numbers of how many I want), 
it will convert, for example the input is 172345 to 157423. Then it will change it to 117722, then if even make it 117733, if odd do the same for the only the last digit. Then make it 173371. It's not specifically finding a palindrome, but it's finding the next highest palindrome number.

blocks|key|1504512|text|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%2B%2B){
++++++++++++int+count=+0+;
++++++++++++for(+n+=+i+;+n+>=1+;n+--+){
++++++++++++++++if(i%25n==0){+++++++++++++
++++++++++++++++++++count+=+count+%2B+1+;
++++++++++++++++//++System.out.println("++Data+:+\n+"++%2Bcount+);++++
++++++++++++++++}+++++++
++++++++++++}
++++++++++++if(count+==+2)
++++++++++++{+++
++++++++++++++++//b+=+b+%2Bi+%2B+""+;
++++++++++++++++
++++++++++++String+ss=++String+.valueOf(i);
++++++++++++//++System.out.print("\n"+%2Bi+);
++++++++++++++++if(isPalindrome(i))
++++++++++++++++{
++++++++++++++++//0+System.out.println("Number+:+"+%2B+i+%2B+"+is+++a+palindrome");
++++++++++++++++
++++++++++++++++++++++++//number2[b]+=+Integer.parseInt(number_ayy[b]);
++++++++++++++++++++++++
++++++++++++++++++++//String+s+=+String+.valueOf(i);
++++++++++++++++++++//System.out.printf("123456",+s);
++++++++++++++++++++resultNum%2B%2B;
++++++++++++++++}
++++++++++++++++else{
++++++++++++++++++++//*System.out.println("Number+:+"+%2B+i+%2B+"+is+Not++a+palindrome");
++++++++++++++++}
++++++++++++++++//System.out.println("++Data+:+\n+"+%2Bss.length()++);++++
++++++++++++}
++++++++//++palindrome(i);
++++++++}
++++++++
++++//++System.out.print("++Data++:+");+
++++//++System.out.println("++Data+:+\n+"++%2Bb+);+
++++++++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+%25+10;+//+ประกาศตัว+แปร+W+ให้+เท่ากับค่า+p+ที่มาจาก+parramiter+ให้+&+mod+กับ++10+คือ+เช่น++2+%25+10+=+2+;+w=+2+;+3%25+10+;+w+=3
+++++++++++r+=+r+*+10+%2B+w;++//+(ให้++R+ที่มาจาก+การประกาศค่ตัวแปร+แล้ว+*+10)+%2B+w++จะมาจากค่า+w+=+p+%25+10;+ที่+mod+ไว้++เช่น+0*10+%2B+2+=+2+
+++++++++++p+=+p+/+10;++//แล้วใช้+p+ที่จมาจากตัว+paramiter+แล้วมาหาร++10++เพราะถ้าไม่มี+ก็จะสามารถพิมพ์ค่าออกมาได้++%7C%7C+ทำไงก็ได้ให้เป็น+0++และเอามาแทนค่ตัวต่อไป+
++++++++}

++++++++//+1+วนวูปเช็คว่า+++(p+!=+0)+หรือไม่+++โดย++p+มาจาก+p+=+number+ที่รับมา+
++++++++//+2+r+=+(r+*+10)+%2B+(p%2510)+;++
++++++++
++++++++//3+++p+=+p+/10+;+เพื่อเช็ค++ว่าให้มันเป็น+0+เพื่อหลุด+Loop+
++++++++if+(number+==+r)+{
++++++++++++//+for(int+count+=+0+;+count+<i+;count+%2B%2B){
++++++++String+s1+=+String.valueOf(i);+++++
++++++++
++++++++++++//countLines(s1);
++++++++++++System.out.println("Number+:+"+%2B+"'"%2Bs1+%2B"'"%2B"++is+++a+palindrome");

++++++++++++return+true;+//เรียก+return+ไป+
++++++++}
++++++++return+false;
++++}
++++
++++public+static+int+countLines(String+str)
++++{
++++++++if+(str+==+null+%7C%7C+str.length()+==+0)
++++++++++++return+0;
++++++++int+lines+=+1;
++++++++int+len+=+str.length();
++++++++for(+int+pos+=+0;+pos+<+len;+pos%2B%2B)+{
++++++++++++char+c+=+str.charAt(pos);
++++++++++++if(+c+==+'\r'+)+{
++++++++++++++++System.out.println("Line+0+:+"+%2B+"'"%2Bstr+);
++++++++++++++++
++++++++++++++++lines%2B%2B;
++++++++++++++++if+(+pos%2B1+<+len+&&+str.charAt(pos%2B1)+==+'\n'+)
++++++++++++++++++++
++++++++++++++++++++System.out.println("Line+:+"+%2B+"'"%2Bstr+);
++++++++++++++++++++
++++++++++++++++++pos%2B%2B;
++++++++++++}+else+if(+c+==+'\n'+)+{
++++++++++++++++lines%2B%2B;
++++++++++++++++
++++++++++++++++System.out.println("Line+2+:+"+%2B+"'"%2Bstr+);
++++++++++++}
++++++++}
++++++++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+%2B+1+);
++++++++lineNumberReader.skip(Long.MAX_VALUE);
++++++++return+lineNumberReader.getLineNumber();
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1504513|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public class PalindromePrime {
 private static int g ,n =0,i,m ; 
 
 private javax.swing.JTextField jTextField;
 

 static String b =&quot;&quot;;
 private static Scanner scanner = new Scanner( System.in ); 
 public static void main(String [] args) throws IOException {
 System.out.print(&quot; Please Inter Data : &quot;); 
 g = scanner.nextInt();
 
 System.out.print(&quot; Please Inter Data 2 : &quot;); 
 m = scanner.nextInt(); 
 
 count(g,m); 
 } 

 public static int count(int L, int R) {
 int resultNum = 0;
 
 for( i= L ; i&lt;= R ;i++){
 int count= 0 ;
 for( n = i ; n &gt;=1 ;n -- ){
 if(i%n==0){ 
 count = count + 1 ;
 // System.out.println(&quot; Data : \n &quot; +count ); 
 } 
 }
 if(count == 2)
 { 
 //b = b +i + &quot;&quot; ;
 
 String ss= String .valueOf(i);
 // System.out.print(&quot;\n&quot; +i );
 if(isPalindrome(i))
 {
 //0 System.out.println(&quot;Number : &quot; + i + &quot; is a palindrome&quot;);
 
 //number2[b] = Integer.parseInt(number_ayy[b]);
 
 //String s = String .valueOf(i);
 //System.out.printf(&quot;123456&quot;, s);
 resultNum++;
 }
 else{
 //*System.out.println(&quot;Number : &quot; + i + &quot; is Not a palindrome&quot;);
 }
 //System.out.println(&quot; Data : \n &quot; +ss.length() ); 
 }
 // palindrome(i);
 }
 
 // System.out.print(&quot; Data : &quot;); 
 // System.out.println(&quot; Data : \n &quot; +b ); 
 return resultNum;
 }
 
 @SuppressWarnings(&quot;unused&quot;)
 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 ให้ &amp; 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 &lt;i ;count ++){
 String s1 = String.valueOf(i); 
 
 //countLines(s1);
 System.out.println(&quot;Number : &quot; + &quot;'&quot;+s1 +&quot;'&quot;+&quot; is a palindrome&quot;);

 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 &lt; len; pos++) {
 char c = str.charAt(pos);
 if( c == '\r' ) {
 System.out.println(&quot;Line 0 : &quot; + &quot;'&quot;+str );
 
 lines++;
 if ( pos+1 &lt; len &amp;&amp; str.charAt(pos+1) == '\n' )
 
 System.out.println(&quot;Line : &quot; + &quot;'&quot;+str );
 
 pos++;
 } else if( c == '\n' ) {
 lines++;
 
 System.out.println(&quot;Line 2 : &quot; + &quot;'&quot;+str );
 }
 }
 return lines;
 }
 
 public static int countLines1(String sd) throws IOException {
 LineNumberReader lineNumberReader = new LineNumberReader(new StringReader(sd));
 int count = 0 ;
 System.out.printf(&quot;Line : &quot; , count = count + 1 );
 lineNumberReader.skip(Long.MAX_VALUE);
 return lineNumberReader.getLineNumber();
 }
}
</code></pre>

blocks|key|1719636|text|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+%2B+num+%25+10;
++++++++num+=+num+/+10;
++++}

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

}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1719637|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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.");

}
</code></pre>

blocks|key|1504682|text|这段代码将int转换为String，然后检查该字符串是否为pallindrom型。它的优点是速度快，缺点是它将int转换为String，从而折衷于问题的完美解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1504683|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%2B1))){
++++++++if(index<length-1){
++++++++++++pallindrome(%2B%2Bindex);
++++++++}
++++}
++++else{
++++++++System.out.println("Not+a+pallindrome");
++++++++System.exit(0);
++++}
}|code-block|syntax|javascript|1504684|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This code converts int to String and then checks if the string is pallindrome. The advantage is that it is fast, the disadvantage being that it converts int to String thereby compromising with the perfect solution to question. 

<pre><code>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&lt;length-1){
 pallindrome(++index);
 }
 }
 else{
 System.out.println("Not a pallindrome");
 System.exit(0);
 }
}
</code></pre>

blocks|key|1504762|text|假设前导零被忽略。下面是一个实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1504763|#include<bits/stdc%2B%2B.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%2510;//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%2B%2B])
++++++++{
++++++++++++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;
}|code-block|syntax|javascript|1504764|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Assuming the leading zeros are ignored. Following is an implementation:

<pre><code>#include&lt;bits/stdc++.h&gt;
using namespace std;
vector&lt;int&gt;digits;
stack&lt;int&gt;digitsRev;
int d,number;
bool isPal=1;//initially assuming the number is palindrome
int main()
{
 cin&gt;&gt;number;
 if(number&lt;10)//if it is a single digit number than it is palindrome
 {
 cout&lt;&lt;"PALINDROME"&lt;&lt;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&lt;&lt;"NOT PALINDROME"&lt;&lt;endl;
 isPal=0;
 break;
 }
 digitsRev.pop();
 }
 //If the digits are equal from both sides than the number is palindrome
 if(isPal==1)cout&lt;&lt;"PALINDROME"&lt;&lt;endl;
}
</code></pre>

blocks|key|1504822|text|在java中检查此解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1504823|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)+%2B+(n+%25+10);
++++++++return+getrev(n+/+10,+initvalue);
++++}|code-block|syntax|javascript|1504824|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Check this solution in java :

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

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

blocks|key|1504900|text|只需通过数学函数获取数字的位数，然后使用'/‘和'%25’操作进行迭代，如下所示。在x=+(x+%25+divider)+/+10之后，我们应该除以100，因为我们做了两次零操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1504901|public+static+boolean+isPalindrome(int+x)+{
++++++++++++if+(x+<+0)+return+false;
++++++++++++if+(x+<+10)+return+true;

++++++++++++int+numDigits+=+(int)(Math.log10(x)%2B1);
++++++++++++int+divider+=+(int)+(Math.pow(10,+numDigits+-+1));
++++++++++++for+(int+i+=+0;+i+<+numDigits+/+2;+i%2B%2B)+{
++++++++++++++++if+(x+/+divider+!=+x+%25+10)
++++++++++++++++++++return+false;
++++++++++++++++x+=+(x+%25+divider)+/+10;
++++++++++++++++divider+/=+100;
++++++++++++}
++++++++++++return+true;
++++++++}|code-block|syntax|javascript|1504902|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Simply get the digit count of the number via Math functions and then iterate by using '/' and '%' operations as follows. After x = (x % divider) / 10, we should divide divider by 100 since we made 2 zero operations.

<pre><code>public static boolean isPalindrome(int x) {
 if (x &lt; 0) return false;
 if (x &lt; 10) return true;

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

blocks|key|1720340|text|public+static+boolean+isPalindrome(int+x)+{
++++++++int+newX+=+x;
++++++++int+newNum+=+0;
++++++++boolean+result+=+false;
++++++++if+(x+>=+0)+{
++++++++++++while+(newX+>=+10)+{
++++++++++++++++newNum+=+newNum%2BnewX+%25+10;
++++++++++++++++newNum+=+newNum+*+10;
++++++++++++++++newX+=+newX+/+10;
++++++++++++}
++++++++++++newNum+%2B=+newX;

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

++++++++else+{

++++++++++++result+=+false;
++++++++}
++++++++return+result;
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1720341|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public static boolean isPalindrome(int x) {
 int newX = x;
 int newNum = 0;
 boolean result = false;
 if (x &gt;= 0) {
 while (newX &gt;= 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;
 }
</code></pre>

blocks|key|1505301|text|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+%25+10;
++++++++++++reverseNumber+=+reverseNumber+*+10+%2B+remainder;
++++++++++++x+=+x+/+10;
++++++++}

++++++++return+reverseNumber;
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1505302|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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 &lt; 0)
 return true;
 return false;
 }

 public int reverseNumber(int x) {

 int reverseNumber = 0;

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

 return reverseNumber;
 }
</code></pre>

blocks|key|1719820|text|一行python代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1719821|def+isPalindrome(number):
++++return+True+if+str(number)+==+''.join(reversed(str(number)))+else+False|code-block|syntax|javascript|1719822|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

One line python code : 

<pre><code>def isPalindrome(number):
 return True if str(number) == ''.join(reversed(str(number))) else False
</code></pre>

blocks|key|1505009|text|就我个人而言，我是这样做的，并且没有重叠；无论字符串的长度是偶数还是奇数，代码都会在正确的位置停止检查匹配字符。上面发布的一些其他方法将在不需要匹配的时候尝试多匹配一次。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1505010|如果我们使用length/2，它仍然可以工作，但它将执行一个不需要执行的额外检查。例如，"pop“的长度是3。3/2+=+1.5，所以它将在i=2时停止检查(因为1<1.5也会在i=1时进行检查)，但我们需要它在0而不是1处停止。第一个"p“在位置0，它将根据位置2中最后一个"p”的长度-1-0(当前位置)进行自我检查，然后我们留下不需要检查的中间字母。当我们做length/2时，我们在1处停止，所以发生的情况是，当i在1位置(+"o")时，会执行额外的检查，并将其与自身进行比较(length-1-i)。|1505011|//+Checks+if+our+string+is+palindromic.
var+ourString+=+"A+Man,+/.,.()%5E&*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%2B/g,+"").replace(/\W/g,"").replace(/_/g,"");
for(i=0;+i<=Math.floor(string.length/2-1);+i%2B%2B)+{
++++++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!");
++++++}
++++}
}|code-block|syntax|javascript|1505012|https://repl.it/FNVZ/1|offset|length|1505013|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|M|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|W|8|@]|9|@$K|X|L|Y|1|Z]]|A|$]]|$1|M|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|J]]]]

Personally I do it this way, and there's no overlap; the code stops checking for matching characters in the correct spot whether the string has an even or odd length. Some of the other methods posted above will attempt to match one extra time when it doesn't need to. 

If we use length/2, it will still work but it will do one additional check that it doesn't need to do. For instance, "pop" is 3 in length. 3/2 = 1.5, so it will stop checking when i = 2(since 1&lt;1.5 it will check when i = 1 as well) but we need it to stop at 0, not one. The first "p" is in position 0, and it will check itself against length-1-0(current position) which is the last "p" in position 2, and then we are left with the center letter that needs no checking. When we do length/2 we stop at 1, so what happens is an extra check is performed with i being on the 1 position(the "o") and compares it to itself (length-1-i).

<pre><code>// Checks if our string is palindromic.
var ourString = "A Man, /.,.()^&amp;*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&lt;=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!");
 }
 }
}
</code></pre>

<a href="https://repl.it/FNVZ/1" rel="nofollow noreferrer">https://repl.it/FNVZ/1</a>

blocks|key|1720193|text|这是我的Java代码。基本上比较字符串的第一个和最后一个值与下一个内部值对，以此类推。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1720194|++++/*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;+%2B%2Bi)+{
++++++++if+(sNumber.charAt(i)+!=+sNumber.charAt((l--)+-1))+{+//comparing+the+first+and+the+last+values+of+the+string
++++++++++++System.out.println(sNumber+%2B"+is+not+a+palindrome+number");
++++++++++++flag+=+false;
++++++++++++break;
++++++++}
++++++++//l--;+//+to+reducing+the+length+value+by+1+
++++}
++++if+(flag)+{
++++++++System.out.println(sNumber+%2B"+is+a+palindrome+number");
++++}|code-block|syntax|javascript|1720195|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is my Java code. Basically comparing the the first and last value of the string and next inner value pair and so forth.

<pre><code> /*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 &lt;= 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");
 }
</code></pre>

blocks|key|1720261|text|见鬼，我疯了！http://www.palindromelist.net/palindromes-d/|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1720262|单步示例:+332是回文数字吗？|1720263|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+%2B=+n+=+23
r+!=+n
r+!=+q
n+=+q+=+3
n+>+r+?+No,+so+332+isn't+a+palindromic+number.|code-block|syntax|javascript|1720264|溢出也不是问题。两个除法是必需的，在代码(C#)中，它们是用乘法来完成的。一个n位数字：~n/2个除法！|1720265|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+%2B=+n;
++++++++if+(r+==+n+%7C%7C+r+==+q)+return+true;
++++++++n+=+q;
++++}
++++return+false;
}|1720266|<+2%5E32的回文数有142948个，它们的总和是137275874705916。|1720267|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%2B%2B;
++++++++Console.WriteLine(sw.Elapsed+%2B+"+"+%2B+c);++++++++++++++++++//+76+s
++++++++n+=+~0u;+c+=+0;+sw.Restart();+while+(n+>+0)+if+(isPal1(n--))+c%2B%2B;
++++++++Console.WriteLine(sw.Elapsed+%2B+"+"+%2B+c);++++++++++++++++++//+42+s
++++++++n+=+~0u;+c+=+0;+sw.Restart();+while+(n+>+0)+if+(isPal2(n--))+c%2B%2B;
++++++++Console.WriteLine(sw.Elapsed+%2B+"+"+%2B+c);++++++++++++++++++//+31+s
++++++++Console.Read();
++++}

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

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

++++static+bool+isPal2(uint+n)
++++{
++++++++if+(n+<+10)+return+true;
++++++++uint+q+=+n+/+10,+r+=+n+-+10+*+q;
++++++++if+(r+==+0+%7C%7C+r+==+q)+return+r+>+0;
++++++++while+((n+=+q)+>+r)
++++++++{
++++++++++++q+/=+10;+r+-=+q;+r+*=+10;+r+%2B=+n;
++++++++++++if+(r+==+n+%7C%7C+r+==+q)+return+true;
++++++++}
++++++++return+false;
++++}
}|1720268|这个看起来更快。|1720269|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%2B%2B;
++++++++Console.WriteLine(sw.Elapsed+%2B+"+"+%2B+c);+++++++++++++++++//+21+s
++++++++Console.Read();
++++}

++++static+bool+isPal(uint+n)
++++{
++++++++return+n+<+100+?+n+<+10+%7C%7C+n+%25+11+==+0+:
++++++++++++++n+<+1000+?+/*++++++++++*/+n+/+100+==+n+%25+10+:
+++++++++++++n+<+10000+?+n+%25+11+==+0+&&+n+/+1000+==+n+%25+10+&&+isP(n)+:
++++++++++++n+<+100000+?+/*++++++++++*/+n+/+10000+==+n+%25+10+&&+isP(n)+:
+++++++++++n+<+1000000+?+n+%25+11+==+0+&&+n+/+100000+==+n+%25+10+&&+isP(n)+:
++++++++++n+<+10000000+?+/*++++++++++*/+n+/+1000000+==+n+%25+10+&&+isP(n)+:
+++++++++n+<+100000000+?+n+%25+11+==+0+&&+n+/+10000000+==+n+%25+10+&&+isP(n)+:
++++++++n+<+1000000000+?+/*++++++++++*/+n+/+100000000+==+n+%25+10+&&+isP(n)+:
+++++++++++++++++++++++++n+%25+11+==+0+&&+n+/+1000000000+==+n+%25+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+%2B=+n;+}+while+(r+<+q);
++++++++return+r+==+q+%7C%7C+r+==+n;
++++}
}|1720270|使用几乎平衡的二进制搜索意大利面条树。|1720271|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%2B%2B))+c%2B%2B;
++++++++Console.WriteLine(sw.Elapsed+%2B+"+"+%2B+c);++++++++++++++//+17+s
++++++++Console.Read();
++++}

++++static+bool+isPal(uint+n)
++++{
++++++++return+n+<+1000000+?+n+<+10000+?+n+<+1000+?+n+<+100+?
++++++++n+<+10+%7C%7C+n+%25+11+==+0+:+n+/+100+==+n+%25+10+:
++++++++n+/+1000+==+n+%25+10+&&+isP(n)+:+n+<+100000+?
++++++++n+/+10000+==+n+%25+10+&&+isP(n)+:
++++++++n+/+100000+==+n+%25+10+&&+isP(n)+:
++++++++n+<+100000000+?+n+<+10000000+?
++++++++n+/+1000000+==+n+%25+10+&&+isP(n)+:
++++++++n+%25+11+==+0+&&+n+/+10000000+==+n+%25+10+&&+isP(n)+:
++++++++n+<+1000000000+?+n+/+100000000+==+n+%25+10+&&+isP(n)+:
++++++++n+%25+11+==+0+&&+n+/+1000000000+==+n+%25+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+%2B=+n;+}+while+(r+<+q);
++++++++return+r+==+q+%7C%7C+r+==+n;
++++}
}|1720272|不平衡颠倒。|1720273|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%2B%2B))+c%2B%2B;
++++++++Console.WriteLine(sw.Elapsed+%2B+"+"+%2B+c);++++++++++++++//+16+s
++++++++Console.Read();
++++}

++++static+bool+isPal(uint+n)
++++{
++++++++return
++++++++n+>+999999999+?+n+%25+11+==+0+&&+n+/+1000000000+==+n+%25+10+&&+isP(n)+:
++++++++n+>+99999999+?+n+/+100000000+==+n+%25+10+&&+isP(n)+:
++++++++n+>+9999999+?+n+%25+11+==+0+&&+n+/+10000000+==+n+%25+10+&&+isP(n)+:
++++++++n+>+999999+?+n+/+1000000+==+n+%25+10+&&+isP(n)+:
++++++++n+>+99999+?+n+%25+11+==+0+&&+n+/+100000+==+n+%25+10+&&+isP(n)+:
++++++++n+>+9999+?+n+/+10000+==+n+%25+10+&&+isP(n)+:
++++++++n+>+999+?+n+%25+11+==+0+&&+n+/+1000+==+n+%25+10+&&+isP(n)+:
++++++++n+>+99+?+n+/+100+==+n+%25+10+:
++++++++n+<+10+%7C%7C+n+%25+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+%2B=+n;+}+while+(r+<+q);
++++++++return+r+==+q+%7C%7C+r+==+n;
++++}
}|1720274|entityMap|0|LINK|mutability|MUTABLE|url|http://www.palindromelist.net/palindromes-d/^0|7|18|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@$A|1D|B|1E|1|1F]]|C|$]]|$1|D|3|E|5|6|7|1G|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1H|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1I|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|1J|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|1K|8|@]|9|@]|C|$]]|$1|Q|3|R|5|H|7|1L|8|@]|9|@]|C|$I|J]]|$1|S|3|T|5|6|7|1M|8|@]|9|@]|C|$]]|$1|U|3|V|5|H|7|1N|8|@]|9|@]|C|$I|J]]|$1|W|3|X|5|6|7|1O|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|H|7|1P|8|@]|9|@]|C|$I|J]]|$1|10|3|11|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|12|3|13|5|H|7|1R|8|@]|9|@]|C|$I|J]]|$1|14|3|-4|5|6|7|1S|8|@]|9|@]|C|$]]]|15|$16|$5|17|18|19|C|$1A|1B]]]]

Dammit, I’m mad! 
<a href="http://www.palindromelist.net/palindromes-d/" rel="nofollow noreferrer">http://www.palindromelist.net/palindromes-d/</a> 
Single steps example: is 332 a palindromic number?

<pre class="lang-C# prettyprint-override"><code>n = 332
q = n / 10 = 33
r = n - 10 * q = 2
r &gt; 0
r != q
n = q = 33
n &gt; r
q = n / 10 = 3
r -= q = 4294967295
r *= 10 = 4294967286
r += n = 23
r != n
r != q
n = q = 3
n &gt; r ? No, so 332 isn't a palindromic number.
</code></pre>

Overflow isn't a problem either.
Two divisions were necessary, in code (C#) they're done with multiplications.
A n-digit number: ~n/2 divisions!

<pre class="lang-cs prettyprint-override"><code>const ulong c0 = 0xcccccccdUL;
static bool isPal(uint n)
{
 if (n &lt; 10) return true;
 uint q = (uint)(c0 * n &gt;&gt; 35);
 uint r = n - 10 * q;
 if (r == 0) return false;
 if (r == q) return true;
 n = q;
 while (n &gt; r)
 {
 q = (uint)(c0 * n &gt;&gt; 35);
 r -= q;
 r *= 10;
 r += n;
 if (r == n || r == q) return true;
 n = q;
 }
 return false;
}
</code></pre>

There are 142948 palindromic numbers &lt; 2^32, their sum is 137275874705916.

<pre class="lang-C# prettyprint-override"><code>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 &gt; 0) if (isPal0(n--)) c++;
 Console.WriteLine(sw.Elapsed + " " + c); // 76 s
 n = ~0u; c = 0; sw.Restart(); while (n &gt; 0) if (isPal1(n--)) c++;
 Console.WriteLine(sw.Elapsed + " " + c); // 42 s
 n = ~0u; c = 0; sw.Restart(); while (n &gt; 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 &gt; 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 &gt;= 10) r = n + (r - (n /= 10)) * 10;
 return u == 10 * r + n;
 }

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

This one seems to be faster.

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

 static bool isPal(uint n)
 {
 return n &lt; 100 ? n &lt; 10 || n % 11 == 0 :
 n &lt; 1000 ? /* */ n / 100 == n % 10 :
 n &lt; 10000 ? n % 11 == 0 &amp;&amp; n / 1000 == n % 10 &amp;&amp; isP(n) :
 n &lt; 100000 ? /* */ n / 10000 == n % 10 &amp;&amp; isP(n) :
 n &lt; 1000000 ? n % 11 == 0 &amp;&amp; n / 100000 == n % 10 &amp;&amp; isP(n) :
 n &lt; 10000000 ? /* */ n / 1000000 == n % 10 &amp;&amp; isP(n) :
 n &lt; 100000000 ? n % 11 == 0 &amp;&amp; n / 10000000 == n % 10 &amp;&amp; isP(n) :
 n &lt; 1000000000 ? /* */ n / 100000000 == n % 10 &amp;&amp; isP(n) :
 n % 11 == 0 &amp;&amp; n / 1000000000 == n % 10 &amp;&amp; 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 &lt; q);
 return r == q || r == n;
 }
}
</code></pre>

With an almost balanced binary search spaghetti tree.

<pre class="lang-C# prettyprint-override"><code>using System;
class Program
{
 static void Main()
 {
 uint n, c; var sw = System.Diagnostics.Stopwatch.StartNew();
 n = c = 0; sw.Restart(); while (n &lt; ~0u) if (isPal(n++)) c++;
 Console.WriteLine(sw.Elapsed + " " + c); // 17 s
 Console.Read();
 }

 static bool isPal(uint n)
 {
 return n &lt; 1000000 ? n &lt; 10000 ? n &lt; 1000 ? n &lt; 100 ?
 n &lt; 10 || n % 11 == 0 : n / 100 == n % 10 :
 n / 1000 == n % 10 &amp;&amp; isP(n) : n &lt; 100000 ?
 n / 10000 == n % 10 &amp;&amp; isP(n) :
 n / 100000 == n % 10 &amp;&amp; isP(n) :
 n &lt; 100000000 ? n &lt; 10000000 ?
 n / 1000000 == n % 10 &amp;&amp; isP(n) :
 n % 11 == 0 &amp;&amp; n / 10000000 == n % 10 &amp;&amp; isP(n) :
 n &lt; 1000000000 ? n / 100000000 == n % 10 &amp;&amp; isP(n) :
 n % 11 == 0 &amp;&amp; n / 1000000000 == n % 10 &amp;&amp; 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 &lt; q);
 return r == q || r == n;
 }
}
</code></pre>

Unbalanced upside down.

<pre class="lang-C# prettyprint-override"><code>using System;
class Program
{
 static void Main()
 {
 uint n, c; var sw = System.Diagnostics.Stopwatch.StartNew();
 n = c = 0; sw.Restart(); while (n &lt; ~0u) if (isPal(n++)) c++;
 Console.WriteLine(sw.Elapsed + " " + c); // 16 s
 Console.Read();
 }

 static bool isPal(uint n)
 {
 return
 n &gt; 999999999 ? n % 11 == 0 &amp;&amp; n / 1000000000 == n % 10 &amp;&amp; isP(n) :
 n &gt; 99999999 ? n / 100000000 == n % 10 &amp;&amp; isP(n) :
 n &gt; 9999999 ? n % 11 == 0 &amp;&amp; n / 10000000 == n % 10 &amp;&amp; isP(n) :
 n &gt; 999999 ? n / 1000000 == n % 10 &amp;&amp; isP(n) :
 n &gt; 99999 ? n % 11 == 0 &amp;&amp; n / 100000 == n % 10 &amp;&amp; isP(n) :
 n &gt; 9999 ? n / 10000 == n % 10 &amp;&amp; isP(n) :
 n &gt; 999 ? n % 11 == 0 &amp;&amp; n / 1000 == n % 10 &amp;&amp; isP(n) :
 n &gt; 99 ? n / 100 == n % 10 :
 n &lt; 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 &lt; q);
 return r == q || r == n;
 }
}
</code></pre>

blocks|key|1720412|text|这个解决方案非常有效，因为我使用的是StringBuilder，这意味着StringBuilder类是作为可变的字符序列实现的。这意味着您要将新的字符串或字符附加到StringBuilder。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1720413|+public+static+boolean+isPal(String+ss){
+++StringBuilder+stringBuilder+=+new+StringBuilder(ss);
+++stringBuilder.reverse();
+++return+ss.equals(stringBuilder.toString());
+}|code-block|syntax|javascript|1720414|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This solution is quite efficient, since I am using StringBuilder which means that the StringBuilder Class is implemented as a mutable sequence of characters. This means that you append new Strings or chars onto a StringBuilder.

<pre class="lang-java prettyprint-override"><code> public static boolean isPal(String ss){
 StringBuilder stringBuilder = new StringBuilder(ss);
 stringBuilder.reverse();
 return ss.equals(stringBuilder.toString());
 }
</code></pre>

blocks|key|1505334|text|我认为这里提供的最好的解决方案是https://stackoverflow.com/a/199203/5704551|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1505335|此解决方案的编码实现可能类似于：|1505336|var+palindromCheck(nums)+=+()+=>+{
++++let+str+=+x.toString()
++++//+%2B+before+str+is+quick+syntax+to+cast+String+To+Number.
++++return+nums+===+%2Bstr.split("").reverse().join("")++
}|code-block|syntax|javascript|1505337|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/199203/5704551^0|G|16|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

I think the best solution provided here <a href="https://stackoverflow.com/a/199203/5704551">https://stackoverflow.com/a/199203/5704551</a>
The coding implementation of this solution can be something like:
<pre><code>var palindromCheck(nums) = () =&gt; {
 let str = x.toString()
 // + before str is quick syntax to cast String To Number.
 return nums === +str.split(&quot;&quot;).reverse().join(&quot;&quot;) 
}
</code></pre>

How do I check if a number is a palindrome?

Any language. Any algorithm. (except the algorithm of making the number a string and then reversing the string).

How do I check if a number is a palindrome?

Python

Java

如何检查一个数字是否为回文？任何语言。任何算法。(除了将数字变为字符串，然后反转字符串的算法除外)。

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

回答 49

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

回答 49

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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