Làm thế nào để tôi kiểm tra nếu một số là một palindrom?

Làm thế nào để tôi kiểm tra nếu một số là một palindrom?

Bất kỳ ngôn ngữ. Bất kỳ thuật toán. (ngoại trừ thuật toán tạo số thành chuỗi và sau đó đảo ngược chuỗi).

Đây là một trong những vấn đề của Project Euler . Khi tôi giải quyết nó trong Haskell, tôi đã làm chính xác những gì bạn đề xuất, chuyển đổi số thành Chuỗi. Sau đó, thật đơn giản để kiểm tra xem chuỗi có phải là một pallindrom không. Nếu nó thực hiện đủ tốt, thì tại sao phải làm cho nó phức tạp hơn? Trở thành một pallindrom là một thuộc tính từ vựng chứ không phải là một toán học.

Đối với bất kỳ số nào:

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

Nếu n == revsau đó numlà một palindrom:

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

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

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

Chỉ hoạt động cho số nguyên. Không rõ ràng từ báo cáo vấn đề nếu số lượng dấu phẩy động hoặc số 0 đứng đầu cần được xem xét.

Trên hầu hết các câu trả lời có một vấn đề nhỏ là biến int có thể có thể bị tràn.

Tham khảo http://articles.leetcode.com/palindrom-number/

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

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

Đẩy từng chữ số riêng lẻ lên một chồng, sau đó bật chúng ra. Nếu nó giống nhau về phía trước và phía sau, thì đó là một bảng màu.

Tôi không nhận thấy bất kỳ câu trả lời nào giải quyết vấn đề này khi không sử dụng thêm dung lượng, tức là tất cả các giải pháp tôi thấy hoặc đã sử dụng một chuỗi hoặc một số nguyên khác để đảo ngược số hoặc một số cấu trúc dữ liệu khác.

Mặc dù các ngôn ngữ như Java bao quanh tràn số nguyên, hành vi này không được xác định trong các ngôn ngữ như C. ( Thử đảo ngược 2147483647 (Integer.MAX_VALUE) trong Java )
Cách khắc phục có thể là sử dụng lâu dài hoặc một cái gì đó, nhưng về mặt phong cách, tôi không hoàn toàn như cách tiếp cận đó

Bây giờ, khái niệm về một số palindromic là số nên đọc cùng một tiến và lùi. Tuyệt quá. Sử dụng thông tin này, chúng ta có thể so sánh chữ số đầu tiên và chữ số cuối cùng. Thủ thuật là, đối với chữ số đầu tiên, chúng ta cần thứ tự của số. Giả sử, 12321. Chia số này bằng 10000 sẽ giúp chúng ta dẫn đầu 1. Có thể lấy ra dấu 1 bằng cách lấy mod với 10. Bây giờ, để giảm số này xuống 232 (12321 % 10000)/10 = (2321)/10 = 232.. Và bây giờ, 10000 sẽ cần phải giảm đi 2 lần. Vì vậy, bây giờ với mã 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;
}

Được chỉnh sửa theo đề nghị của Hardik để bao gồm các trường hợp có số không trong số.

Trong Python, có một cách lặp lại nhanh chóng.

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

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

Điều này cũng ngăn ngừa các vấn đề về bộ nhớ với đệ quy (như lỗi StackOverflow trong Java)

Cách nhanh nhất tôi biết:

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

Chỉ để cho vui, cái này cũng hoạt động.

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

ngoại trừ làm cho số một chuỗi và sau đó đảo ngược chuỗi.

Tại sao lại bỏ qua giải pháp đó? Thật dễ dàng để thực hiện và có thể đọc được . Nếu bạn được hỏi không có máy tính trong tay liệu2**10-23 là một bảng màu thập phân hay không, chắc chắn bạn sẽ kiểm tra nó bằng cách viết nó ra dưới dạng thập phân.

Trong Python ít nhất, khẩu hiệu 'hoạt động chuỗi chậm hơn số học' thực sự là sai. Tôi đã so sánh thuật toán số học của Smink với đảo ngược chuỗi đơn giảnint(str(i)[::-1]) . Không có sự khác biệt đáng kể về tốc độ - nó đã xảy ra đảo ngược chuỗi nhanh hơn một chút.

Trong các ngôn ngữ được biên dịch (C / C ++), khẩu hiệu có thể giữ, nhưng có một rủi ro tràn lỗi với số lượng lớn.

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)

Kết quả tính bằng giây (thấp hơn là tốt hơn):

strung 1.50960231881 số học 1.69729960569

Tôi đã trả lời vấn đề Euler bằng cách sử dụng một cách rất tàn bạo. Đương nhiên, có một thuật toán thông minh hơn được hiển thị khi tôi đến chủ đề diễn đàn liên quan đã mở khóa mới. Cụ thể, một thành viên đã xử lý Begoner có cách tiếp cận mới lạ như vậy, tôi quyết định thực hiện lại giải pháp của mình bằng thuật toán của mình. Phiên bản của anh ấy là Python (sử dụng các vòng lặp lồng nhau) và tôi đã thực hiện lại nó trong Clojure (sử dụng một vòng lặp / recur).

Ở đây để bạn giải trí:

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

Cũng có câu trả lời Lisp chung, nhưng chúng không thể chấp nhận được đối với tôi.

Đây là một phiên bản Scheme xây dựng một chức năng sẽ hoạt động chống lại bất kỳ cơ sở nào. Nó có một kiểm tra dự phòng: trả về false một cách nhanh chóng nếu số đó là bội số của cơ sở (kết thúc bằng 0).
Và nó không xây dựng lại toàn bộ số đảo ngược, chỉ một nửa.
Đó là tất cả những gì chúng ta cần.

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

Giải pháp đệ quy trong ruby, mà không chuyển đổi số thành chuỗi.

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

palindrome?(55655)

Phiên bản 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
}

Tắt các chữ số đầu tiên và cuối cùng và so sánh chúng cho đến khi bạn hết. Có thể có một chữ số còn lại hoặc không, nhưng một trong hai cách, nếu tất cả các chữ số bật ra khớp với nhau, đó là một bảng màu.

Đây là một giải pháp nữa trong c ++ bằng cách sử dụng các mẫu. Giải pháp này sẽ làm việc cho trường hợp so sánh chuỗi palindrom không nhạy.

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

một phương thức có hệ số hằng số tốt hơn một chút so với phương thức @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

Đây là phiên bản af #:

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

Một số là palindromic nếu biểu diễn chuỗi của nó là palindromic:

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

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

Để kiểm tra số đã cho có phải là Palindrom hay không (Mã 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");
    }
}

Rất nhiều giải pháp được đăng ở đây đảo ngược số nguyên và lưu trữ nó trong một biến sử dụng thêm không gian O(n), nhưng đây là một giải pháp có O(1)không gian.

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

Tôi luôn luôn sử dụng giải pháp python này do sự nhỏ gọn của nó.

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

Thử cái này:

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

Dưới đây là một giải pháp sử dụng danh sách như ngăn xếp trong 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

popping stack chỉ xem xét phía bên phải của số để so sánh và nó không nhanh chóng để giảm kiểm tra

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

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

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

Cách đệ quy, không hiệu quả lắm, chỉ cung cấp một tùy chọn

(Mã 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)