Comment vérifier si un numéro est un palindrome?
Comment vérifier si un numéro est un palindrome?
N'importe quel langage. N'importe quel algorithme. (sauf l'algorithme consistant à transformer le nombre en chaîne puis à l'inverser).
Ceci est un des problèmes du projet Euler . Quand je l'ai résolu dans Haskell, j'ai fait exactement ce que vous suggérez, convertissez le nombre en chaîne. Il est alors trivial de vérifier que la chaîne est un pallindrome. Si cela fonctionne assez bien, alors pourquoi se donner la peine de le rendre plus complexe? Être pallindrome est une propriété lexicale plutôt que mathématique.
Pour tout nombre donné:
n = num;
rev = 0;
while (num > 0)
{
Dig = num % 10;
rev = rev * 10 + Dig;
num = num / 10;
}
Si n == rev, alors num est un 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!")
Fonctionne uniquement pour les entiers. L’énoncé du problème ne dit pas clairement si les nombres en virgule flottante ou les zéros à gauche doivent être pris en compte.
Au-dessus de la plupart des réponses, le problème est que la variable int peut éventuellement déborder.
Reportez-vous à 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;
}
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;
}
Poussez chaque chiffre sur une pile, puis supprimez-les. Si c'est la même chose d'avant en arrière, c'est un palindrome.
Je n'ai remarqué aucune réponse qui résolve ce problème en n'utilisant aucun espace supplémentaire, c'est-à-dire que toutes les solutions que j'ai vues utilisaient une chaîne ou un autre entier pour inverser le nombre, ou d'autres structures de données.
Bien que des langages tels que Java recouvrent un dépassement d'entier, ce comportement n'est pas défini dans des langages tels que C. [Essayez d'inverser 2147483647 (Integer.MAX_VALUE) en Java]. mais, stylistiquement, je n'aime pas trop cette approche.
Maintenant, le concept de nombre palindromique est que le nombre doit lire la même chose en avant et en arrière. Génial. En utilisant cette information, nous pouvons comparer le premier chiffre et le dernier chiffre. Trick est, pour le premier chiffre, nous avons besoin de l'ordre du numéro. Dites, 12321. Si nous divisons cela par 10000, nous aurions le premier 1. Le dernier 1 peut être récupéré en prenant le mod avec 10. Maintenant, pour le réduire à 232. (12321 % 10000)/10 = (2321)/10 = 232. Et maintenant, il faudrait réduire le facteur 10000 de 2. Alors, passons maintenant au code 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;
}
Edité selon la suggestion de Hardik afin de couvrir les cas où le nombre contient des zéros.
En Python, il existe un moyen rapide et itératif.
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 évite également les problèmes de mémoire liés à la récursivité (comme les erreurs StackOverflow en Java)
sauf en faisant du nombre une chaîne puis en inversant la chaîne.
Pourquoi rejeter cette solution? Il est facile à mettre en œuvre et lisible . Si on vous demandait sans ordinateur si 2**10-23 est un palindrome décimal, vous devriez le tester en l'écrivant en décimal.
En python au moins, le slogan "Les opérations sur les chaînes de caractères sont plus lentes que l'arithmétique" est en réalité faux. J'ai comparé l'algorithme arithmétique de Smink à l'inversion de chaîne simple int(str(i)[::-1]). Il n'y avait pas de différence significative de vitesse - il est arrivé que l'inversion de chaîne était légèrement plus rapide.
Dans les langages de bas niveau (C/C++), le slogan peut être utilisé, mais un risque de déborder des erreurs 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)
Résultats en secondes (bas est mieux):
cordée 1.50960231881
arithmétique 1.69729960569
Juste pour le plaisir, celui-ci fonctionne également.
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;
Voici une version de schéma qui construit une fonction qui fonctionnera contre n'importe quelle base. Il a un contrôle de redondance: retourne rapidement false si le nombre est un multiple de la base (se termine par 0) ..__ Et il ne reconstruit pas la totalité du nombre inversé, 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)))))))
Le moyen le plus rapide que je connaisse:
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;
}
J'ai répondu au problème d'Euler en utilisant une méthode très brutale. Naturellement, il y avait un algorithme beaucoup plus intelligent à l'écran lorsque je suis arrivé au nouveau fil de discussion associé déverrouillé. À savoir, un membre qui est passé par la poignée Begoner avait une telle approche nouvelle que j'ai décidé de réimplémenter ma solution en utilisant son algorithme. Sa version était en Python (en utilisant des boucles imbriquées) et je l'ai réimplémentée en Clojure (en utilisant une seule boucle/récurrente).
Ici pour votre amusement:
(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)))
Il y avait aussi des réponses communes à LISP, mais elles étaient impossibles à supporter.
Solution récursive en Ruby, sans convertir le nombre en chaîne
def palindrome?(x, a=x, b=0)
return x==b if a<1
palindrome?(x, a/10, b*10 + a%10)
end
palindrome?(55655)
Version 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
}
Détachez les premier et dernier chiffres et comparez-les jusqu'à épuisement. Il peut rester un chiffre ou non, mais dans tous les cas, si tous les chiffres sautés correspondent, il s'agit d'un palindrome.
Voici une autre solution en c ++ utilisant des modèles. Cette solution fonctionnera pour la comparaison de chaînes palindromes insensible à la casse.
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;
}
voici une version 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
Pour vérifier si le numéro indiqué est Palindrome ou non (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");
}
}
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."
J'utilise toujours cette solution python en raison de sa compacité.
def isPalindrome(number):
return int(str(number)[::-1])==number
Un nombre est 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))
une méthode avec un facteur constant un peu meilleur que la méthode @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
Un grand nombre des solutions publiées ici inversent le nombre entier et le stockent dans une variable utilisant un espace supplémentaire, à savoir O(n), mais voici une solution avec O(1) space.
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
Voici la réponse dans Swift. Il lit les nombres de gauche et de droite et les compare s’ils sont identiques . De cette manière, nous ne ferons jamais face à un problème de dépassement d’entier(qui peut se produire avec la méthode du nombre inversé)comme nous ne créons pas un autre numéro.
Pas:
- Obtenir la longueur du nombre
- Boucle de longueur + 1(first) -> 0
- Obtenez le chiffre et le dernier chiffre
- si les deux chiffres ne sont pas égaux, retourne faux, car le nombre n'est pas palindrome
- je --
- ignorer le dernier chiffre de num (num = num/10)
fin des toilettes retour vrai
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 }
Essaye ça:
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();
}
}
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");
}
}
}
Je ne sais pas si c'est la meilleure réponse, et je suis novice en programmation. (c'est en 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);
}
}
Donc, pour ce code, entrez un nombre (j'ai fait des nombres aléatoires dont je veux), Il sera converti, par exemple, l'entrée est 172345 à 157423. Ensuite, il le changera en 117722, puis si même le faire 117733 , si impair, faites de même pour le dernier chiffre seulement. Alors rendez-vous 173371. Il ne s'agit pas spécifiquement de trouver un palindrome, mais de rechercher le prochain numéro de palindrome le plus élevé.
Obtenez simplement le nombre de chiffres du nombre via les fonctions mathématiques, puis effectuez une itération en utilisant les opérations '/' et '%' comme suit. Après x = (x% divider)/10, nous devrions diviser le diviseur par 100 puisque nous avons effectué 2 opérations nulles.
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;
}
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"
Essaye ça:
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)
il suffit de rappeler les fonctions
Cette solution est assez efficace car j'utilise StringBuilder, ce qui signifie que la classe StringBuilder est implémentée sous la forme d'une séquence de caractères modifiable. Cela signifie que vous ajoutez de nouvelles chaînes ou de nouveaux caractères à un StringBuilder.
public static boolean isPal(String ss){
StringBuilder stringBuilder = new StringBuilder(ss);
stringBuilder.reverse();
return ss.equals(stringBuilder.toString());
}
Vérifiez 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);
}
Code python à une ligne:
def isPalindrome(number):
return True if str(number) == ''.join(reversed(str(number))) else False
il semble que le plus simple serait de trouver le nombre opposé et de comparer les deux:
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!");
}
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.");
}
Ceci est mon code Java. Fondamentalement, comparer la première et la dernière valeur de la chaîne et la paire de valeur interne suivante, etc.
/*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");
}
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 int en String, compromettant ainsi 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);
}
}
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;
}
Cela semblait fonctionner aussi, mais avez-vous envisagé la possibilité que le nombre inversé puisse déborder? En cas de débordement, le comportement est spécifique au langage (pour Java, le nombre est dépassé, mais en C/C++, son comportement n'est pas défini). Beurk.
Il s'avère que comparer depuis les deux bouts est plus facile. Commencez par comparer le premier et le dernier chiffre. S'ils ne sont pas identiques, ce ne doit pas être un palindrome. S'ils sont identiques, coupez un chiffre des deux côtés et continuez jusqu'à ce qu'il ne vous reste plus de chiffres, ce qui vous permettra de conclure qu'il doit s'agir d'un palindrome.
Maintenant, obtenir et couper le dernier chiffre est facile. Cependant, obtenir et couper le premier chiffre de manière générique nécessite un peu de réflexion. La solution ci-dessous s'en occupe.
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;
}
classe publique 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();
}
}
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;
}
Voici une liste d'utilisations de solutions sous forme de 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
sauter la pile ne considère que le côté le plus à droite du nombre pour la comparaison et échoue rapidement pour réduire les contrôles
Personnellement je le fais de cette façon, et il n'y a pas de chevauchement; le code cesse de rechercher les caractères correspondants au bon endroit si la chaîne a une longueur paire ou impaire. Certaines des méthodes décrites ci-dessus tenteront de faire correspondre une fois de plus si cela n'est pas nécessaire.
Si nous utilisons length/2, cela fonctionnera quand même, mais une vérification supplémentaire sera effectuée. Par exemple, "pop" a une longueur de 3. 3/2 = 1.5, donc il arrêtera de vérifier quand i = 2 (puisque 1 <1.5, il vérifiera aussi quand i = 1), mais nous devons arrêter à 0, pas un. Le premier "p" est en position 0 et il va se vérifier par rapport à la longueur-1-0 (position actuelle) qui est le dernier "p" en position 2, puis nous nous retrouvons avec la lettre centrale qui ne nécessite aucune vérification. Lorsque nous faisons la longueur/2, nous nous arrêtons à 1; il se produit donc une vérification supplémentaire avec i étant sur la position 1 (le "o") et la compare à elle-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!");
}
}
}
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;
}
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)
Manière récursive, pas très efficace, juste 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)
Voici un moyen.
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");
}
}
}
Je suis allé avec l'approche régulière en convertissant le nombre en chaîne, puis en convertissant encore chaîne en charArray . Parcourant charArray et trouver si nombre à des positions sont égales ou non .. Note.: Ne pas inverser 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;