it-swarm.asia

如何检查数字是否是回文?

如何检查数字是否是回文?

任何语言。任何算法。 (除了使数字成为字符串然后反转字符串的算法)。

120
Esteban Araya

这是 项目欧拉问题之一 。当我在Haskell中解决它时,我完全按照你的建议,将数字转换为字符串。然后检查该字符串是否为pallindrome是微不足道的。如果它表现得足够好,那为什么还要把它变得更复杂呢?作为一个pallindrome是一个词汇属性而不是数学属性。

123
Dan Dyer

对于任何给定的数量:

 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;
263
Jorge Ferreira
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!")

仅适用于整数。从问题陈述中不清楚是否需要考虑浮点数或前导零。

24
Mark Ransom

在大多数具有微不足道问题的答案之上,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;
}
20
Jiaji Li
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;
}
14
Robert Gamble

将每个数字推入堆栈,然后将其弹出。如果前后相同,那就是回文。

9
Grant Limberg

我没有注意到任何解决这个问题的答案,没有使用额外的空间,即我看到的所有解决方案都使用了字符串,或者使用另一个整数来反转数字或其他一些数据结构。

尽管像Java这样的语言会在整数溢出上回转,但是这种行为在C语言中是未定义的。[ 尝试在Java中反转2147483647(Integer.MAX_VALUE) ]解决方法可能是使用long或者东西,但风格上,我不太喜欢那种做法。

现在,回文数字的概念是该数字应该向前和向后读取相同的数字。大。使用此信息,我们可以比较第一个数字和最后一个数字。特技是,对于第一个数字,我们需要数字的顺序。比方说,12321。将它除以10000可以得到前导1.尾随1可以通过将模数取为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;
}

编辑为 Hardik 的建议,以涵盖数字中有零的情况。

7
Debosmit Ray

在Python中,有一种快速,迭代的方式。

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

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

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

6
ytpillai

除了使数字成为一个字符串,然后反转字符串。

为何解雇该解决方案? 它易于实现和可读 。如果你被问到手头没有计算机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

5
Colonel Panic

只是为了好玩,这个也有效。

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;
4
Toon Krijthe

这是一个Scheme版本,它构造一个可以对任何基础起作用的函数。它有一个冗余检查:如果数字是基数的倍数,则快速返回false(以0结尾)。并且它不会重建整个反转数字,只有一半。这就是我们所需要的一切。

(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)))))))
4
z5h

我知道的最快方式:

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

我用非常粗暴的方式回答了欧拉问题。当然,当我到达新的未锁定的相关论坛帖子时,有一个更聪明的算法。也就是说,经过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)))

还有共同的LISP答案,但它们对我来说是不可思议的。

4
Chris Vest

Ruby中的递归解决方案,无需将数字转换为字符串

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

palindrome?(55655)
3
dre-hh

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
}
3
Thomas Modeneis

弹出第一个和最后一个数字并比较它们直到用完为止。可能有一个数字,或者没有,但无论如何,如果所有弹出的数字都匹配,则它是回文。

2
Eli

这是使用模板的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;
}
2
VikramChopde

这是一个f#版本:

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

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

检查给定的数字是Palindrome与否(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");
    }
}
1
sort_01out
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."
1
Rock

由于其紧凑性,我总是使用这个python解决方案。

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

如果一个数字的字符串表示为回文,则该数字是回文:

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

一个比@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
1
eku

这里发布的很多解决方案都会反转整数并将其存储在一个使用额外空间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
1
Sunny Raj

以下是Swift的答案。它从左侧和右侧读取数字,如果它们相同则进行比较。这样做我们永远不会遇到整数溢出问题 (可能在反转数字方法时出现) 因为我们没有创建另一个数字。

脚步:

  1. 获取数字的长度
  2. 从长度+ 1(first) - > 0循环
  3. 获取ith数字并获得最后一位数字
  4. 如果两个数字不相等则返回false,因为数字不是回文
  5. 一世 -
  6. 丢弃num的最后一位数(num = num/10)
  7. loo的结束返回true

    func isPalindrom(_ input: Int) -> Bool {
           if input < 0 {
                return false
            }
    
            if input < 10 {
                return true
            }
    
            var num = input
            let length = Int(log10(Float(input))) + 1
            var i = length
    
            while i > 0 && num > 0 {
    
                let ithDigit = (input / Int(pow(10.0, Double(i) - 1.0)) ) % 10
                let r = Int(num % 10)
    
                if ithDigit != r {
                    return false
                }
    
                num = num / 10
                i -= 1
            }
    
            return true
        }
    
0
Adnan Aftab

试试这个:

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();
}
}
0
vivek
 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");
      }
  }
}
0
BLaaaaaa

不确定这是否是最佳答案,而且我是编程新手。 (它是用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.它没有专门找到回文,但它找到了下一个最高的回文数。

0
hs2345

只需通过Math函数获取数字的数字计数,然后使用'/'和'%'操作进行迭代,如下所示。在x =(x%divider)/ 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;
        }
0
huseyin
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"
0
Jhutan Debnath

试试这个:

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)

只需回调功能

0
user3615696

这个解决方案非常有效,因为我使用的是StringBuilder,这意味着StringBuilder类是作为一个可变的字符序列实现的。这意味着您将新的字符串或字符附加到StringBuilder上。

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

用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);
    }
0
Abdou Amari

一行python代码:

def isPalindrome(number):
    return True if str(number) == ''.join(reversed(str(number))) else False
0
Pradip Das
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.");

}
0
gadolf

这是我的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");
    }
0
Sucharith

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

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

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

static void pallindrome(int index){
    if(pallindromer.charAt(index)==pallindromer.charAt(length-(index+1))){
        if(index<length-1){
            pallindrome(++index);
        }
    }
    else{
        System.out.println("Not a pallindrome");
        System.exit(0);
    }
}
0
Ankur Tewari
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;
}
0
NewCoder

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

}

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

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

        else {

            result = false;
        }
        return result;
    }
0
SuL

我个人这样做,并没有重叠;代码停止检查正确位置中的匹配字符,无论字符串是偶数还是奇数。上面发布的一些其他方法将尝试在不需要的时候匹配一个额外的时间。

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

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

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

https://repl.it/FNVZ/1

0
Shaun L
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;
}
0
MarianG
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)
0
mario

递归方式,效率不高,只提供一个选项

(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) 
0
user1552891

这是一种方式。

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

我通过将数字转换为字符串然后进一步将字符串转换为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;
0
Mr. Wonderful