ฉันจะตรวจสอบได้อย่างไรว่าตัวเลขนั้นเป็นพาลินโดรม?

ฉันจะตรวจสอบได้อย่างไรว่าตัวเลขนั้นเป็นพาลินโดรม?

ภาษาใดก็ได้ อัลกอริทึมใด ๆ (ยกเว้นอัลกอริทึมในการทำให้ตัวเลขเป็นสตริงแล้วย้อนกลับสตริง)

นี้เป็นหนึ่งในปัญหาที่โครงการออยเลอร์ เมื่อฉันแก้ไขมันใน Haskell ฉันได้ทำตามที่คุณแนะนำแล้วให้แปลงตัวเลขเป็น String เป็นเรื่องเล็กน้อยที่จะต้องตรวจสอบว่าสตริงเป็นแพลลินโดรม ถ้ามันทำงานได้ดีพอทำไมต้องทำให้ซับซ้อนมากขึ้น? การเป็นแพลลินโดรมเป็นคุณสมบัติของคำศัพท์มากกว่าคุณสมบัติทางคณิตศาสตร์

สำหรับหมายเลขใด ๆ :

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

หากn == revแล้วnumเป็น palindrome:

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

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

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

ใช้ได้กับจำนวนเต็มเท่านั้น ไม่ชัดเจนจากคำชี้แจงปัญหาหากต้องพิจารณาตัวเลขทศนิยมหรือเลขศูนย์นำหน้า

เหนือคำตอบส่วนใหญ่ที่มีปัญหาเล็กน้อยคือตัวแปร int อาจล้น

อ้างถึงhttp://articles.leetcode.com/palindrome-number/

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

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

ดันตัวเลขแต่ละตัวลงในสแต็กจากนั้นดึงออก ถ้าข้างหน้าและข้างหลังเหมือนกันแสดงว่าเป็นพาลินโดรม

ฉันไม่สังเกตเห็นคำตอบใด ๆ ที่แก้ไขปัญหานี้โดยไม่ใช้ช่องว่างเพิ่มเติมนั่นคือวิธีแก้ปัญหาทั้งหมดที่ฉันเห็นอาจใช้สตริงหรือจำนวนเต็มอื่นเพื่อย้อนกลับตัวเลขหรือโครงสร้างข้อมูลอื่น ๆ

แม้ว่าภาษาเช่น Java จะล้อมรอบด้วยจำนวนเต็มล้น แต่พฤติกรรมนี้ไม่ได้กำหนดไว้ในภาษาเช่น C. ( ลองย้อนกลับ 2147483647 (Integer.MAX_VALUE) ใน Java )
วิธีแก้ปัญหาคือใช้ long หรือบางอย่าง แต่ในทางโวหารฉันไม่ค่อย ชอบแนวทางนั้น

ตอนนี้แนวคิดของเลขพาลินโดรมิกคือจำนวนควรอ่านไปข้างหน้าและข้างหลังเหมือนกัน ยิ่งใหญ่ เมื่อใช้ข้อมูลนี้เราสามารถเปรียบเทียบตัวเลขหลักแรกและหลักสุดท้าย เคล็ดลับคือสำหรับหลักแรกเราต้องการลำดับของตัวเลข กล่าวว่า 12321. แบ่งนี้โดย 10000 จะได้รับเรา 1. ชั้นนำต่อท้าย 1 สามารถเรียกดูได้โดยการ mod กับ 10 ตอนนี้เพื่อลดนี้ (12321 % 10000)/10 = (2321)/10 = 232232 และตอนนี้ 10,000 จะต้องลดลงด้วยปัจจัย 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เพื่อให้ครอบคลุมกรณีที่มีเลขศูนย์

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

นอกจากนี้ยังป้องกันปัญหาหน่วยความจำเกี่ยวกับการเรียกซ้ำ (เช่นข้อผิดพลาด StackOverflow ใน Java)

วิธีที่เร็วที่สุดที่ฉันรู้:

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

เพื่อความสนุกสนานอันนี้ก็ใช้ได้เช่นกัน

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;

ยกเว้นการทำให้ตัวเลขเป็นสตริงแล้วย้อนกลับสตริง

ทำไมต้องยกเลิกการแก้ปัญหานั้น? มันเป็นเรื่องง่ายที่จะใช้และสามารถอ่านได้ หากคุณถูกถามโดยไม่มีคอมพิวเตอร์อยู่ในมือว่า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

ฉันตอบปัญหาออยเลอร์โดยใช้วิธีที่ดุร้ายมาก โดยปกติแล้วมีอัลกอริทึมที่ชาญฉลาดกว่ามากที่แสดงเมื่อฉันไปที่เธรดฟอรัมที่เกี่ยวข้องกับการปลดล็อกใหม่ กล่าวคือสมาชิกคนหนึ่งที่เดินตามมือจับ Begoner มีวิธีการที่แปลกใหม่ทำให้ฉันตัดสินใจที่จะนำโซลูชันของฉันไปใช้ใหม่โดยใช้อัลกอริทึมของเขา เวอร์ชันของเขาอยู่ใน Python (โดยใช้ลูปที่ซ้อนกัน) และฉันนำมาใช้ใหม่ใน Clojure (โดยใช้ single loop / ซ้ำ)

ที่นี่เพื่อความบันเทิงของคุณ:

(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 ทั่วไปเช่นกัน แต่พวกเขาไม่พอใจสำหรับฉัน

นี่คือเวอร์ชัน Scheme ที่สร้างฟังก์ชันที่จะทำงานร่วมกับฐานใด ๆ มีการตรวจสอบความซ้ำซ้อน: ส่งคืนเท็จอย่างรวดเร็วหากตัวเลขเป็นผลคูณของฐาน (ลงท้ายด้วย 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)))))))

วิธีการแก้ซ้ำในทับทิมโดยไม่ต้องแปลงตัวเลขเป็นสตริง

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

palindrome?(55655)

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
}

นำตัวเลขแรกและหลักสุดท้ายมาเปรียบเทียบกันจนกว่าจะหมด อาจมีตัวเลขเหลืออยู่หรือไม่ก็ได้ แต่ไม่ว่าจะด้วยวิธีใดก็ตามหากตัวเลขทั้งหมดที่โผล่ออกมาตรงกันแสดงว่าเป็นพาลินโดรม

นี่คืออีกหนึ่งวิธีแก้ปัญหาใน c ++ โดยใช้เทมเพลต โซลูชันนี้จะใช้ได้กับการเปรียบเทียบสตริง palindrome แบบตัวพิมพ์เล็กและใหญ่

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

วิธีที่มีค่าคงที่ที่ดีกว่าวิธี @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

นี่คือรุ่น 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

ตัวเลขคือ palindromic ถ้าการแทนค่าสตริงเป็น 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."

เพื่อตรวจสอบหมายเลขที่ระบุว่าเป็น Palindrome หรือไม่ (Java Code)

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

วิธีแก้ปัญหาจำนวนมากที่โพสต์ไว้ที่นี่จะย้อนกลับจำนวนเต็มและเก็บไว้ในตัวแปรซึ่งใช้ช่องว่างเพิ่มเติมซึ่งก็คือO(n)แต่นี่คือโซลูชันที่มีO(1)ช่องว่าง

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

ฉันใช้โซลูชัน python นี้เสมอเนื่องจากความกะทัดรัด

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

ลองสิ่งนี้:

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

นี่คือรายการการใช้งานโซลูชันเป็นสแต็กใน python:

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

การเปิดสแต็กจะพิจารณาเฉพาะด้านขวาสุดของตัวเลขเพื่อเปรียบเทียบและล้มเหลวอย่างรวดเร็วในการลดการตรวจสอบ

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

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

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

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

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

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

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

วิธีการเรียกซ้ำไม่ค่อยมีประสิทธิภาพเพียงแค่ให้ตัวเลือก

(รหัส Python)

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

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