Comment puis-je vérifier si un nombre est un palindrome?

Pour un nombre donné:

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

Si n == rev puis num est un palindrome:

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

Au-dessus de la plupart des réponses ayant un banal problème est que la variable int pourraient éventuellement débordement.

Reportez-vous à 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;
}

Pousser chaque chiffre sur une pile, puis pop off. Si c'est la même avant et en arrière, c'est un palindrome.

En Python, il est rapide, de façon itérative.

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

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

Cela empêche également les problèmes de mémoire avec la récursivité (comme StackOverflow erreur en Java)

à l'exception de rendre le numéro de chaîne, puis de l'inversion de la chaîne.

Pourquoi rejeter cette solution? Mise en œuvre est simple et lisible. Si vous avez été invité à pas d'ordinateur à portée de main si 2**10-23 est un décimal palindrome, vous aimeriez certainement un test écrit en décimal.

En Python au moins, le slogan "les opérations de la chaîne sont plus lents que l'arithmétique" est en fait faux. J'ai comparé Smink de l'arithmétique de l'algorithme à chaîne simple inversion int(str(i)[::-1]). Il n'y avait pas de différence significative de la vitesse - c'est arrivé chaîne de renversement a été légèrement plus rapide.

Dans les langages compilés (C/C++) le slogan pourrait tenir, mais on risque des erreurs de dépassement avec un grand nombre.

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)

Des résultats en quelques secondes (en bas c'est mieux):

enfilées 1.50960231881
l'arithmétique 1.69729960569

Voici un Schéma de la version qui construit une fonction qui vont à l'encontre de toute la base. Il a un contrôle de redondance: return false rapidement si le nombre est un multiple de la base (qui se termine en 0).

Et il ne faut pas reconstruire l'ensemble de la inversée nombre, seulement la moitié.

C'est tout ce dont nous avons besoin.

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

Golang version:

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
}

Pop off le premier et le dernier, les chiffres et les comparer jusqu'à ce que de vous lancer. Il y a peut être un chiffre à gauche, ou pas, mais de toute façon, si tout le sauté chiffres correspondent, c'est un palindrome.

une méthode avec un peu meilleur facteur constant que @sminks méthode:

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

Un nombre palindrome si sa représentation sous forme de chaîne est palindrome:

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

Pour vérifier le nombre donné est Palindrome ou pas (Code 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");
    }
}

J'utilise toujours cette python solution en raison de sa compacité.

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

Ici est une solution de l'usage des listes, comme les piles en 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, la pile ne considère que le côté droit de la le nombre à des fins de comparaison et ne parvient pas rapidement à réduire les contrôles

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)

Récursive façon, pas très efficace, il suffit de fournir une option

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

Essayez ceci:

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)

juste de retour d'appel les fonctions

Je suis allé à la régulière approche par la conversion de numéro de chaîne, puis en plus de la conversion de la chaîne de charArray.
Traversée par le biais de charArray et de trouver si le nombre à des postes sont égaux ou non.
Remarque-: Pas d'inversion de la chaîne.

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;

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"

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

}

Ce code convertit int en String, puis vérifie si la chaîne est pallindrome. L'avantage est qu'il est rapide, l'inconvénient étant qu'il convertit en int en String, ce qui compromet la solution parfaite à la question.

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

Cochez cette solution en 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);
    }

Personnellement, je le fais de cette façon, et il n'y a pas de chevauchement; le code s'arrête la vérification de caractères correspondant à l'endroit approprié si la chaîne a un pair ou impair de la longueur. Certains des autres méthodes posté ci-dessus va tenter de match une fois de plus quand il n'est pas nécessaire.

Si nous utilisons longueur/2, il faudra encore travailler, mais il va faire une vérification supplémentaire qu'il n'a pas besoin de le faire. Par exemple, "pop" est à 3 dans la longueur. 3/2 = 1.5, donc il va arrêter de vérifier lorsque i = 2(depuis le 1<1.5 on va vérifier si i = 1, aussi), mais nous avons besoin d'elle pour s'arrêter à 0, pas un seul. Le premier "p" est en position 0, et il vérifie lui-même à l'encontre de longueur-1-0(position actuelle) qui est le dernier "p" en position 2, puis on se retrouve avec le centre de la lettre qui n'a pas besoin de vérifier. Quand nous faisons de longueur/2 nous nous arrêtons à 1, ce qui se passe est une vérification supplémentaire est effectuée avec je sur la position 1(le "o") et la compare à lui-même (longueur-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

Ci-dessous est la réponse à swift.
Il lit les nombres de gauche et de droite et de les comparer entre eux s'ils sont de même.
Faire de cette façon, nous ne seront jamais confrontés à un problème de dépassement d'entier (qui peuvent se produire sur l'inversion de numéro de méthode) que nous ne sommes pas en créer un autre nombre.

Suit:

1. Obtenir la longueur de la nombre
2. Boucle de longueur + 1(première) --> 0
3. Obtenir ith chiffres & get dernier chiffre
4. si les deux chiffres ne sont pas égaux return false que le nombre n'est pas palindrome
5. i --
6. jeter derniers chiffres du num (num = num /10)

7. fin de loo return 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
       }
   

Cette solution est très efficace, depuis que je suis à l'aide de StringBuilder ce qui signifie que la Classe StringBuilder est mis en œuvre comme une mutable séquence de caractères. Cela signifie que vous ajoutez de nouvelles Chaînes ou des caractères sur un StringBuilder.

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

Zut, je suis fou!
http://www.palindromelist.net/palindromes-d/

Étapes de exemple: est-332 un nombre palindrome?

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.

De débordement n'est pas un problème non plus.
Les deux divisions ont été nécessaires, dans le code (C#), ils sont fait avec les multiplications.
Un n-chiffres: ~n/2 divisions!

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

Il y a 142948 palindromique numéros de < 2^32, leur somme est 137275874705916.

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++;
Console.WriteLine(sw.Elapsed + " " + c);                  //76 s
n = ~0u; c = 0; sw.Restart(); while (n > 0) if (isPal1(n--)) c++;
Console.WriteLine(sw.Elapsed + " " + c);                  //42 s
n = ~0u; c = 0; sw.Restart(); while (n > 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 > 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 >= 10) r = n + (r - (n /= 10)) * 10;
return u == 10 * r + n;
}
static bool isPal2(uint n)
{
if (n < 10) return true;
uint q = n / 10, r = n - 10 * q;
if (r == 0 || r == q) return r > 0;
while ((n = q) > r)
{
q /= 10; r -= q; r *= 10; r += n;
if (r == n || r == q) return true;
}
return false;
}
}

Celui-ci semble être plus rapide.

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++;
Console.WriteLine(sw.Elapsed + " " + c);                 //21 s
Console.Read();
}
static bool isPal(uint n)
{
return n < 100 ? n < 10 || n % 11 == 0 :
n < 1000 ? /*          */ n / 100 == n % 10 :
n < 10000 ? n % 11 == 0 && n / 1000 == n % 10 && isP(n) :
n < 100000 ? /*          */ n / 10000 == n % 10 && isP(n) :
n < 1000000 ? n % 11 == 0 && n / 100000 == n % 10 && isP(n) :
n < 10000000 ? /*          */ n / 1000000 == n % 10 && isP(n) :
n < 100000000 ? n % 11 == 0 && n / 10000000 == n % 10 && isP(n) :
n < 1000000000 ? /*          */ n / 100000000 == n % 10 && isP(n) :
n % 11 == 0 && n / 1000000000 == n % 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 += n; } while (r < q);
return r == q || r == n;
}
}

Presque équilibré binaire de recherche spaghetti arbre.

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++)) c++;
Console.WriteLine(sw.Elapsed + " " + c);              //17 s
Console.Read();
}
static bool isPal(uint n)
{
return n < 1000000 ? n < 10000 ? n < 1000 ? n < 100 ?
n < 10 || n % 11 == 0 : n / 100 == n % 10 :
n / 1000 == n % 10 && isP(n) : n < 100000 ?
n / 10000 == n % 10 && isP(n) :
n / 100000 == n % 10 && isP(n) :
n < 100000000 ? n < 10000000 ?
n / 1000000 == n % 10 && isP(n) :
n % 11 == 0 && n / 10000000 == n % 10 && isP(n) :
n < 1000000000 ? n / 100000000 == n % 10 && isP(n) :
n % 11 == 0 && n / 1000000000 == n % 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 += n; } while (r < q);
return r == q || r == n;
}
}

Déséquilibré à l'envers.

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++)) c++;
Console.WriteLine(sw.Elapsed + " " + c);              //16 s
Console.Read();
}
static bool isPal(uint n)
{
return
n > 999999999 ? n % 11 == 0 && n / 1000000000 == n % 10 && isP(n) :
n > 99999999 ? n / 100000000 == n % 10 && isP(n) :
n > 9999999 ? n % 11 == 0 && n / 10000000 == n % 10 && isP(n) :
n > 999999 ? n / 1000000 == n % 10 && isP(n) :
n > 99999 ? n % 11 == 0 && n / 100000 == n % 10 && isP(n) :
n > 9999 ? n / 10000 == n % 10 && isP(n) :
n > 999 ? n % 11 == 0 && n / 1000 == n % 10 && isP(n) :
n > 99 ? n / 100 == n % 10 :
n < 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 < q);
return r == q || r == n;
}
}