如何檢查數字是否是迴文數字？

Question

如何檢查數字是否是迴文數字？

任何語言。任何算法。 （除了使數字成爲字符串然後反轉字符串的算法除外）。

Answer 1

這是one of the Project Euler problems。當我在Haskell中解決它時，我完全按照你的建議做了，將該數字轉換爲一個String。然後檢查該字符串是否是一個惡意代碼，這很簡單。如果性能足夠好，那麼爲什麼要讓它更復雜？作爲一個絕望症是一種詞彙屬性，而不是一種數學屬性。

Answer 2

將每個單獨的數字推入堆棧，然後彈出它們。如果前後相同，則是迴文。

Answer 3

對於任何給定編號：

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; 

Answer 4

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!") 

作品只有整數。從問題陳述中不清楚是否需要考慮浮點數或前導零。

Answer 5

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

Answer 6

將第一個和最後一個數字分開並比較它們，直到用完爲止。可能還有一個數字，或者不是，但是無論哪種方式，如果所有彈出的數字匹配，它都是迴文。

Answer 7

我用非常暴躁的方式回答了歐拉問題。當然，當我到達新的未鎖定的相關論壇主題時，顯示的算法會更聰明。也就是說，一個經過Begoner處理的成員有這樣一種新穎的方法，我決定用他的算法重新實現我的解決方案。他的版本是Python（使用嵌套循環），我用Clojure重新實現了它（使用單個循環/循環）。

在這裏爲您的娛樂：

(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的回答爲好，但他們ungrokable給我。

Answer 8

只是爲了好玩，這一個也適用。

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

Answer 9

這是一個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))))))) 

Answer 10

比@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 

Answer 11

這裏的自動對焦＃版本：

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 

Answer 12

一個數是迴文，如果它的字符串表示是迴文：

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

Answer 13

除了讓數字成爲一個字符串然後顛倒字符串。

爲什麼忽略該解決方案？ 它很容易實現和可讀。如果詢問你手頭沒有電腦，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

Answer 14

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." 

Answer 15

嘗試這種情況：

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

Answer 16

這裏是一個溶液usings列表作爲在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 

出棧僅考慮用於比較的數的最右側和它未能快速減少檢查

Answer 17

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

Answer 18

上面大多數有一個小問題的答案是int變量可能會溢出。

參考http://leetcode.com/2012/01/palindrome-number.html

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

Answer 19

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) 

Answer 20

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

Answer 21

遞歸的方式，效率不是很高，只是提供一個選項

（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) 

Answer 22

它似乎像最簡單的事情將是找到第四e反對號碼並比較兩者：

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

Answer 23

C＃和F＃中的遞歸解決方案。

C＃：

static bool IsPalindrome(int n) 
{ 
    string s = n.ToString(); 
    if(s.Length <= 1) return true; 
    return (s.First() == s.Last()) && IsPalindrome(int.Parse(s.Substring(1,s.Length-2))); 
} 

F＃：

let rec isPalindrome (n) = 
    let s = string(n) 
    if s.Length <= 1 then true 
    else (s |> Seq.head) = (s |> Seq.last) && isPalindrome (int(s.Substring(1,s.Length-2))) 

Answer 24

試試這個：

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) 

剛回叫功能

Answer 25

要檢查給定的數字迴文與否（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"); 
    } 
} 

Answer 26

這是一個使用模板的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; 
} 

Answer 27

這是一種方法。

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

Answer 28

我用常規方法將數字轉換爲字符串，然後再將字符串轉換爲charArray。 遍歷charArray並查找位置上的數字是否相等。 注意：不能倒轉字符串。

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; 

Answer 29

很多貼在這裏的解決方案的逆轉在使用額外的空間是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 

Answer 30

由於其緊湊性，我總是使用這個python解決方案。

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

Answer 31

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

Answer 32

Golang版本：

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 
} 

Answer 33

在Python，有一個快速的，迭代的方式。

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

這也可以防止內存問題與遞歸（像Java中的StackOverflow錯誤）我知道

Answer 34

的最快方法：

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

Answer 35

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" 

Answer 36

不知道這是最好的答案，我是編程新手。 （這是在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.它不是專門找到迴文，而是找到次高迴文數。

Answer 37

公共類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(); 
} 

}在紅寶石

Answer 38

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

} 

Answer 39

遞歸溶液，沒有數量轉換爲字符串

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

palindrome?(55655) 

Answer 40

該代碼將int轉換爲字符串，然後檢查如果字符串是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); 
    } 
} 

Answer 41

我沒有注意到，解決不使用額外的空間，這個問題的任何答案，即所有的解決方案，我看到無論是使用一個字符串，或另一個整數扭轉號碼，或者一些其他數據結構。

雖然像Java語言環繞整數溢出，這種行爲是在語言如C不確定[嘗試在Java中倒車2147483647（Integer.MAX_VALUE的） 解決辦法可能是使用長什麼的，但是，在風格上，我不太喜歡這種方法。

現在，迴文數的概念是數字應該讀取相同的向前和向後。大。使用這些信息，我們可以比較第一位數字和最後一位數字。竅門是，對於第一個數字，我們需要數字的順序。比如說，12321，將它除以10000會使我們成爲領先的1.後面的1可以通過將mod與10進行檢索。現在，將其降低到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; 
} 

Answer 42

一行Python代碼：

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

Answer 43

#include<bits/stdc++.h> 
using namespace std; 

int main(void) 

{ 
    string s; 
    cin>>s; 

    for(int i=0; i<=s.size()/2; i++) 
    { 
     if(s[i]!=s[s.size()-i-1]) 
     { 
      cout<<"NOT PALINDROME"; 
      return 0; 
     } 
    } 
    cout<<"PALINDROME"; 
} 

Answer 44

檢查該解決方案中的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); 
    } 

Answer 45

簡單地得到通過數學函數數的位數計數，然後通過迭代使用'/'和'％'操作如下。在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; 
     } 

Answer 46

我個人是這樣做的，沒有重疊;代碼將停止檢查正確位置中的匹配字符，無論該字符串的長度是偶數還是奇數。上面發佈的其他一些方法將嘗試在不需要時匹配一個額外的時間。

如果我們使用長度/ 2，它仍然可以工作，但它會做一個額外的檢查，它不需要做。例如，「流行」的長度是3。 3/2 = 1.5，所以它會停止檢查當我= 2（因爲1 < 1.5它會檢查當我= 1），但我們需要它停止在0，而不是一個。第一個「p」在位置0，它將檢查自身與位置2中最後一個「p」的長度-1-0（當前位置），然後我們留下中間字母，不需要檢查。當我們做長度爲2的時候，我們停在1，所以會發生一個額外的檢查，我在1的位置（「o」）執行額外的檢查並將其與自身比較（長度爲1）。

// 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

Answer 47

這是我的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"); 
    } 

Answer 48

該死的，我瘋了！ 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; 
}