Dado un número entero positivo, escribe una función que devuelva verdadero si el número dado es un palíndromo, en caso contrario, falso. Por ejemplo, 12321 es un palíndromo, pero 1451 no es un palíndromo.
Práctica recomendada La suma de dígitos es palindrome o no ¡Pruébelo!
Método 1:
Sea el número dado en uno . Un método simple para este problema es primero dígitos inversos de en uno , luego compare el reverso de en uno con en uno . Si ambos son iguales, devuelve verdadero; en caso contrario, falso.
A continuación se muestra un método interesante inspirado en el método n.° 2 de este correo. La idea es crear una copia de en uno y pasar recursivamente la copia por referencia, y pasar en uno por valor. En las llamadas recursivas, dividir en uno por 10 mientras baja por el árbol de recursividad. Mientras asciende en el árbol de recursividad, divida la copia entre 10. Cuando se encuentran en una función para la cual todas las llamadas secundarias terminaron, el último dígito de en uno será el dígito i desde el principio y el último dígito de la copia será el dígito i desde el final.
C++
programa de numeros primos en java
// A recursive C++ program to check> // whether a given number> // is palindrome or not> #include> using> namespace> std;> > // A function that returns true only> // if num contains one> // digit> int> oneDigit(>int> num)> {> > >// Comparison operation is faster> >// than division> >// operation. So using following> >// instead of 'return num> >// / 10 == 0;'> >return> (num>= 0 && número<10);> }> > // A recursive function to find> // out whether num is> // palindrome or not. Initially, dupNum> // contains address of> // a copy of num.> bool> isPalUtil(>int> num,>int>* dupNum)> {> > >// Base case (needed for recursion> >// termination): This> >// statement mainly compares the> >// first digit with the> >// last digit> >if> (oneDigit(num))> >return> (num == (*dupNum) % 10);> > >// This is the key line in this> >// method. Note that all> >// recursive calls have a separate> >// copy of num, but they> >// all share same copy of *dupNum.> >// We divide num while> >// moving up the recursion tree> >if> (!isPalUtil(num / 10, dupNum))> >return> false>;> > >// The following statements are> >// executed when we move up> >// the recursion call tree> >*dupNum /= 10;> > >// At this point, if num%10 contains> >// i'th digit from> >// beginning, then (*dupNum)%10> >// contains i'th digit> >// from end> >return> (num % 10 == (*dupNum) % 10);> }> > // The main function that uses> // recursive function> // isPalUtil() to find out whether> // num is palindrome or not> int> isPal(>int> num)> {> > >// Check if num is negative,> >// make it positive> >if> (num <0)> >num = -num;> > >// Create a separate copy of num,> >// so that modifications> >// made to address dupNum don't> >// change the input number.> >// *dupNum = num> >int>* dupNum =>new> int>(num);> > >return> isPalUtil(num, dupNum);> }> > // Driver program to test> // above functions> int> main()> {> >int> n = 12321;> >isPal(n) ? cout <<>'Yes
'>: cout <<>'No'> << endl;> > >n = 12;> >isPal(n) ? cout <<>'Yes
'>: cout <<>'No'> << endl;> > >n = 88;> >isPal(n) ? cout <<>'Yes
'>: cout <<>'No'> << endl;> > >n = 8999;> >isPal(n) ? cout <<>'Yes
'>: cout <<>'No'>;> >return> 0;> }> > // this code is contributed by shivanisinghss2110> |
>
>
C
#include> #include> > // A function that returns true only> // if num contains one digit> int> oneDigit(>int> num)> {> >// Comparison operation is faster> >// than division operation.> >// So using the following instead of 'return num / 10 == 0;'> >return> (num>= 0 && número<10);> }> > // A recursive function to find out whether> // num is palindrome or not.> // Initially, dupNum contains the address of a copy of num.> bool> isPalUtil(>int> num,>int>* dupNum)> {> >// Base case (needed for recursion termination):> >// This statement mainly compares the first digit with the last digit.> >if> (oneDigit(num))> >return> (num == (*dupNum) % 10);> > >// This is the key line in this method.> >// Note that all recursive calls have a separate copy of num,> >// but they all share the same copy of *dupNum.> >// We divide num while moving up the recursion tree.> >if> (!isPalUtil(num / 10, dupNum))> >return> false>;> > >// The following statements are executed when we move up the recursion call tree.> >*dupNum /= 10;> > >// At this point, if num % 10 contains the i'th digit from the beginning,> >// then (*dupNum) % 10 contains the i'th digit from the end.> >return> (num % 10 == (*dupNum) % 10);> }> > // The main function that uses the recursive function> // isPalUtil() to find out whether num is palindrome or not.> bool> isPal(>int> num)> {> >// Check if num is negative, make it positive.> >if> (num <0)> >num = -num;> > >// Create a separate copy of num, so that modifications> >// made to the address dupNum don't change the input number.> >int> dupNum = num;> > >return> isPalUtil(num, &dupNum);> }> > // Driver program to test above functions> int> main()> {> >int> n = 12321;> >isPal(n) ?>printf>(>'Yes
'>) :>printf>(>'No
'>);> > >n = 12;> >isPal(n) ?>printf>(>'Yes
'>) :>printf>(>'No
'>);> > >n = 88;> >isPal(n) ?>printf>(>'Yes
'>) :>printf>(>'No
'>);> > >n = 8999;> >isPal(n) ?>printf>(>'Yes
'>) :>printf>(>'No
'>);> > >return> 0;> }> |
>
>
Java
// A recursive Java program to> // check whether a given number> // is palindrome or not> import> java.io.*;> import> java.util.*;> > public> class> CheckPalindromeNumberRecursion {> > >// A function that returns true> >// only if num contains one digit> >public> static> int> oneDigit(>int> num) {> > >if> ((num>=>0>) && (num <>10>))> >return> 1>;> >else> >return> 0>;> >}> > >public> static> int> isPalUtil> >(>int> num,>int> dupNum)>throws> Exception {> > >// base condition to return once we> >// move past first digit> >if> (num ==>0>) {> >return> dupNum;> >}>else> {> >dupNum = isPalUtil(num />10>, dupNum);> >}> > >// Check for equality of first digit of> >// num and dupNum> >if> (num %>10> == dupNum %>10>) {> >// if first digit values of num and> >// dupNum are equal divide dupNum> >// value by 10 to keep moving in sync> >// with num.> >return> dupNum />10>;> >}>else> {> >// At position values are not> >// matching throw exception and exit.> >// no need to proceed further.> >throw> new> Exception();> >}> > >}> > >public> static> int> isPal(>int> num)> >throws> Exception {> > >if> (num <>0>)> >num = (-num);> > >int> dupNum = (num);> > >return> isPalUtil(num, dupNum);> >}> > >public> static> void> main(String args[]) {> > >int> n =>12421>;> >try> {> >isPal(n);> >System.out.println(>'Yes'>);> >}>catch> (Exception e) {> >System.out.println(>'No'>);> >}> >n =>1231>;> >try> {> >isPal(n);> >System.out.println(>'Yes'>);> >}>catch> (Exception e) {> >System.out.println(>'No'>);> >}> > >n =>12>;> >try> {> >isPal(n);> >System.out.println(>'Yes'>);> >}>catch> (Exception e) {> >System.out.println(>'No'>);> >}> > >n =>88>;> >try> {> >isPal(n);> >System.out.println(>'Yes'>);> >}>catch> (Exception e) {> >System.out.println(>'No'>);> >}> > >n =>8999>;> >try> {> >isPal(n);> >System.out.println(>'Yes'>);> >}>catch> (Exception e) {> >System.out.println(>'No'>);> >}> >}> }> > // This code is contributed> // by Nasir J> |
>
>
Python3
# A recursive Python3 program to check> # whether a given number is palindrome or not> > # A function that returns true> # only if num contains one digit> def> oneDigit(num):> > ># comparison operation is faster> ># than division operation. So> ># using following instead of> ># 'return num / 10 == 0;'> >return> ((num>>=> 0>)>and> >(num <>10>))> > # A recursive function to find> # out whether num is palindrome> # or not. Initially, dupNum> # contains address of a copy of num.> def> isPalUtil(num, dupNum):> > ># Base case (needed for recursion> ># termination): This statement> ># mainly compares the first digit> ># with the last digit> >if> oneDigit(num):> >return> (num>=>=> (dupNum[>0>])>%> 10>)> > ># This is the key line in this> ># method. Note that all recursive> ># calls have a separate copy of> ># num, but they all share same> ># copy of *dupNum. We divide num> ># while moving up the recursion tree> >if> not> isPalUtil(num>/>/>10>, dupNum):> >return> False> > ># The following statements are> ># executed when we move up the> ># recursion call tree> >dupNum[>0>]>=> dupNum[>0>]>/>/>10> > ># At this point, if num%10> ># contains i'th digit from> ># beginning, then (*dupNum)%10> ># contains i'th digit from end> >return> (num>%> 10> =>=> (dupNum[>0>])>%> 10>)> > # The main function that uses> # recursive function isPalUtil()> # to find out whether num is> # palindrome or not> def> isPal(num):> ># If num is negative,> ># make it positive> >if> (num <>0>):> >num>=> (>->num)> > ># Create a separate copy of> ># num, so that modifications> ># made to address dupNum> ># don't change the input number.> >dupNum>=> [num]># *dupNum = num> > >return> isPalUtil(num, dupNum)> > # Driver Code> n>=> 12321> if> isPal(n):> >print>(>'Yes'>)> else>:> >print>(>'No'>)> > n>=> 12> if> isPal(n) :> >print>(>'Yes'>)> else>:> >print>(>'No'>)> > n>=> 88> if> isPal(n) :> >print>(>'Yes'>)> else>:> >print>(>'No'>)> > n>=> 8999> if> isPal(n) :> >print>(>'Yes'>)> else>:> >print>(>'No'>)> > # This code is contributed by mits> |
>
>
C#
// A recursive C# program to> // check whether a given number> // is palindrome or not> using> System;> > class> GFG> {> > // A function that returns true> // only if num contains one digit> public> static> int> oneDigit(>int> num)> {> >// comparison operation is> >// faster than division> >// operation. So using> >// following instead of> >// 'return num / 10 == 0;'> >if>((num>= 0) &&(núm.<10))> >return> 1;> >else> >return> 0;> }> > // A recursive function to> // find out whether num is> // palindrome or not.> // Initially, dupNum contains> // address of a copy of num.> public> static> int> isPalUtil(>int> num,> >int> dupNum)> {> >// Base case (needed for recursion> >// termination): This statement> >// mainly compares the first digit> >// with the last digit> >if> (oneDigit(num) == 1)> >if>(num == (dupNum) % 10)> >return> 1;> >else> >return> 0;> > >// This is the key line in> >// this method. Note that> >// all recursive calls have> >// a separate copy of num,> >// but they all share same> >// copy of *dupNum. We divide> >// num while moving up the> >// recursion tree> >if> (isPalUtil((>int>)(num / 10), dupNum) == 0)> >return> -1;> > >// The following statements> >// are executed when we move> >// up the recursion call tree> >dupNum = (>int>)(dupNum / 10);> > >// At this point, if num%10> >// contains i'th digit from> >// beginning, then (*dupNum)%10> >// contains i'th digit from end> >if>(num % 10 == (dupNum) % 10)> >return> 1;> >else> >return> 0;> }> > // The main function that uses> // recursive function isPalUtil()> // to find out whether num is> // palindrome or not> public> static> int> isPal(>int> num)> {> >// If num is negative,> >// make it positive> >if> (num <0)> >num = (-num);> > >// Create a separate copy> >// of num, so that modifications> >// made to address dupNum> >// don't change the input number.> >int> dupNum = (num);>// *dupNum = num> > >return> isPalUtil(num, dupNum);> }> > // Driver Code> public> static> void> Main()> {> int> n = 12321;> if>(isPal(n) == 0)> >Console.WriteLine(>'Yes'>);> else> >Console.WriteLine(>'No'>);> > n = 12;> if>(isPal(n) == 0)> >Console.WriteLine(>'Yes'>);> else> >Console.WriteLine(>'No'>);> > n = 88;> if>(isPal(n) == 1)> >Console.WriteLine(>'Yes'>);> else> >Console.WriteLine(>'No'>);> > n = 8999;> if>(isPal(n) == 0)> >Console.WriteLine(>'Yes'>);> else> >Console.WriteLine(>'No'>);> }> }> > // This code is contributed by mits> |
>
>
JavaScript
> // A recursive javascript program to> // check whether a given number> // is palindrome or not> > >// A function that returns true> >// only if num contains one digit> >function> oneDigit(num) {> > >if> ((num>= 0) && (núm.<10))> >return> 1;> >else> >return> 0;> >}> > >function> isPalUtil> >(num , dupNum) {> > >// base condition to return once we> >// move past first digit> >if> (num == 0) {> >return> dupNum;> >}>else> {> >dupNum = isPalUtil(parseInt(num / 10), dupNum);> >}> > >// Check for equality of first digit of> >// num and dupNum> >if> (num % 10 == dupNum % 10) {> >// if first digit values of num and> >// dupNum are equal divide dupNum> >// value by 10 to keep moving in sync> >// with num.> >return> parseInt(dupNum / 10);> >}>else> {> >// At position values are not> >// matching throw exception and exit.> >// no need to proceed further.> >throw> e;> >}> > >}> > >function> isPal(num)> >{> > >if> (num <0)> >num = (-num);> > >var> dupNum = (num);> > >return> isPalUtil(num, dupNum);> >}> > > > >var> n = 1242;> >try> {> >isPal(n);> >document.write(>' Yes'>);> >}>catch> (e) {> >document.write(>' No'>);> >}> >n = 1231;> >try> {> >isPal(n);> >document.write(>' Yes'>);> >}>catch> (e) {> >document.write(>' No'>);> >}> > >n = 12;> >try> {> >isPal(n);> >document.write(>' Yes'>);> >}>catch> (e) {> >document.write(>' No'>);> >}> > >n = 88;> >try> {> >isPal(n);> >document.write(>' Yes'>);> >}>catch> (e) {> >document.write(>' No'>);> >}> > >n = 8999;> >try> {> >isPal(n);> >document.write(>' Yes'>);> >}>catch> (e) {> >document.write(>' No'>);> >}> > // This code is contributed by Amit Katiyar> > |
>
>
PHP
espacio de línea numeroso
// A recursive PHP program to // check whether a given number // is palindrome or not // A function that returns true // only if num contains one digit function oneDigit($num) { // comparison operation is faster // than division operation. So // using following instead of // 'return num / 10 == 0;' return (($num>= 0) && ($núm.<10)); } // A recursive function to find // out whether num is palindrome // or not. Initially, dupNum // contains address of a copy of num. function isPalUtil($num, $dupNum) { // Base case (needed for recursion // termination): This statement // mainly compares the first digit // with the last digit if (oneDigit($num)) return ($num == ($dupNum) % 10); // This is the key line in this // method. Note that all recursive // calls have a separate copy of // num, but they all share same // copy of *dupNum. We divide num // while moving up the recursion tree if (!isPalUtil((int)($num / 10), $dupNum)) return -1; // The following statements are // executed when we move up the // recursion call tree $dupNum = (int)($dupNum / 10); // At this point, if num%10 // contains i'th digit from // beginning, then (*dupNum)%10 // contains i'th digit from end return ($num % 10 == ($dupNum) % 10); } // The main function that uses // recursive function isPalUtil() // to find out whether num is // palindrome or not function isPal($num) { // If num is negative, // make it positive if ($num <0) $num = (-$num); // Create a separate copy of // num, so that modifications // made to address dupNum // don't change the input number. $dupNum = ($num); // *dupNum = num return isPalUtil($num, $dupNum); } // Driver Code $n = 12321; if(isPal($n) == 0) echo 'Yes
'; else echo 'No
'; $n = 12; if(isPal($n) == 0) echo 'Yes
'; else echo 'No
'; $n = 88; if(isPal($n) == 1) echo 'Yes
'; else echo 'No
'; $n = 8999; if(isPal($n) == 0) echo 'Yes
'; else echo 'No
'; // This code is contributed by m_kit ?>> |
>
>Producción
Yes No Yes No>
Complejidad del tiempo: O(log n)
Espacio Auxiliar: O(log n)
Para comprobar que un número es palíndromo o no sin utilizar ningún espacio adicional
Método 2: usar el método string()
- Cuando el número de dígitos de ese número excede 1018, no podemos tomar ese número como un número entero ya que el rango de long long int no satisface el número dado.
- Entonces tome la entrada como una cadena, ejecute un bucle desde el inicio hasta la longitud/2 y verifique desde el primer carácter (numérico) hasta el último carácter de la cadena y del penúltimo al penúltimo, y así sucesivamente... Si algún carácter no coincide, la cadena No sería un palíndromo.
A continuación se muestra la implementación del enfoque anterior.
C++14
// C++ implementation of the above approach> #include> using> namespace> std;> > // Function to check palindrome> int> checkPalindrome(string str)> {> >// Calculating string length> >int> len = str.length();> > >// Traversing through the string> >// upto half its length> >for> (>int> i = 0; i // Comparing i th character // from starting and len-i // th character from end if (str[i] != str[len - i - 1]) return false; } // If the above loop doesn't return then it is // palindrome return true; } // Driver Code int main() { // taking number as string string st = '112233445566778899000000998877665544332211'; if (checkPalindrome(st) == true) cout << 'Yes'; else cout << 'No'; return 0; } // this code is written by vikkycirus> |
>
>
Java
// Java implementation of the above approach> import> java.io.*;> > class> GFG{> > // Function to check palindrome> static> boolean> checkPalindrome(String str)> {> > >// Calculating string length> >int> len = str.length();> > >// Traversing through the string> >// upto half its length> >for>(>int> i =>0>; i 2; i++) { // Comparing i th character // from starting and len-i // th character from end if (str.charAt(i) != str.charAt(len - i - 1)) return false; } // If the above loop doesn't return then // it is palindrome return true; } // Driver Code public static void main(String[] args) { // Taking number as string String st = '112233445566778899000000998877665544332211'; if (checkPalindrome(st) == true) System.out.print('Yes'); else System.out.print('No'); } } // This code is contributed by subhammahato348> |
analizando cadena a int
>
>
Python3
# Python3 implementation of the above approach> > # function to check palindrome> def> checkPalindrome(>str>):> > ># Run loop from 0 to len/2> >for> i>in> range>(>0>,>len>(>str>)>/>/>2>):> >if> str>[i] !>=> str>[>len>(>str>)>->i>->1>]:> >return> False> > ># If the above loop doesn't> >#return then it is palindrome> >return> True> > > # Driver code> st>=> '112233445566778899000000998877665544332211'> if>(checkPalindrome(st)>=>=> True>):> >print>(>'it is a palindrome'>)> else>:> >print>(>'It is not a palindrome'>)> |
>
>
C#
// C# implementation of the above approach> using> System;> > class> GFG{> > // Function to check palindrome> static> bool> checkPalindrome(>string> str)> {> > >// Calculating string length> >int> len = str.Length;> > >// Traversing through the string> >// upto half its length> >for>(>int> i = 0; i { // Comparing i th character // from starting and len-i // th character from end if (str[i] != str[len - i - 1]) return false; } // If the above loop doesn't return then // it is palindrome return true; } // Driver Code public static void Main() { // Taking number as string string st = '112233445566778899000000998877665544332211'; if (checkPalindrome(st) == true) Console.Write('Yes'); else Console.Write('No'); } } // This code is contributed by subhammahato348> |
>
>
JavaScript
> > // Javascript implementation of the above approach> > // Function to check palindrome> function> checkPalindrome(str)> {> >// Calculating string length> >var> len = str.length;> > >// Traversing through the string> >// upto half its length> >for> (>var> i = 0; i // Comparing ith character // from starting and len-ith // character from end if (str[i] != str[len - i - 1]) return false; } // If the above loop doesn't return then it is // palindrome return true; } // Driver Code // taking number as string let st = '112233445566778899000000998877665544332211'; if (checkPalindrome(st) == true) document.write('Yes'); else document.write('No'); // This code is contributed by Mayank Tyagi> |
>
>Producción
Yes>
Complejidad del tiempo: O(|cadena|)
Espacio Auxiliar :O(1)
Método 3:
Este es el método más sencillo para comprobar si un número es palíndromo o no. Este enfoque se puede utilizar cuando el número de dígitos del número dado es menor que 10^18 porque si el número de dígitos de ese número excede 10^18, no podemos tomar ese número como un número entero ya que el rango de largo largo int no satisface el número dado.
Para verificar si el número dado es palíndromo o no, simplemente invertiremos los dígitos del número dado y verificaremos si el reverso de ese número es igual al número original o no. Si el reverso del número es igual a ese número, el número será Palíndromo; de lo contrario, no será un Palíndromo.
C++
// C++ program to check if a number is Palindrome> #include> using> namespace> std;> // Function to check Palindrome> bool> checkPalindrome(>int> n)> {> >int> reverse = 0;> >int> temp = n;> >while> (temp != 0) {> >reverse = (reverse * 10) + (temp % 10);> >temp = temp / 10;> >}> >return> (reverse> >== n);>// if it is true then it will return 1;> >// else if false it will return 0;> }> int> main()> {> >int> n = 7007;> >if> (checkPalindrome(n) == 1) {> >cout <<>'Yes
'>;> >}> >else> {> >cout <<>'No
'>;> >}> >return> 0;> }> // This code is contributed by Suruchi Kumari> |
aprendizaje automático y tipos
>
>
Java
/*package whatever //do not write package name here */> > import> java.io.*;> > class> GFG {> >// Java program to check if a number is Palindrome> > >// Function to check Palindrome> >static> boolean> checkPalindrome(>int> n)> >{> >int> reverse =>0>;> >int> temp = n;> >while> (temp !=>0>) {> >reverse = (reverse *>10>) + (temp %>10>);> >temp = temp />10>;> >}> >return> (reverse == n);>// if it is true then it will return 1;> >// else if false it will return 0;> >}> > >// Driver Code> >public> static> void> main(String args[])> >{> >int> n =>7007>;> >if> (checkPalindrome(n) ==>true>) {> >System.out.println(>'Yes'>);> >}> >else> {> >System.out.println(>'No'>);> >}> >}> }> > // This code is contributed by shinjanpatra> |
>
>
Python3
# Python3 program to check if a number is Palindrome> > # Function to check Palindrome> def> checkPalindrome(n):> > >reverse>=> 0> >temp>=> n> >while> (temp !>=> 0>):> >reverse>=> (reverse>*> 10>)>+> (temp>%> 10>)> >temp>=> temp>/>/> 10> > >return> (reverse>=>=> n)># if it is true then it will return 1;> ># else if false it will return 0;> > # driver code> n>=> 7007> if> (checkPalindrome(n)>=>=> 1>):> >print>(>'Yes'>)> > else>:> >print>(>'No'>)> > # This code is contributed by shinjanpatra> |
>
>
C#
np.ceros
// C# program to check if a number is Palindrome> > using> System;> > class> GFG {> > >// Function to check Palindrome> >static> bool> checkPalindrome(>int> n)> >{> >int> reverse = 0;> >int> temp = n;> >while> (temp != 0) {> >reverse = (reverse * 10) + (temp % 10);> >temp = temp / 10;> >}> >return> (> >reverse> >== n);>// if it is true then it will return 1;> >// else if false it will return 0;> >}> > >// Driver Code> >public> static> void> Main(>string>[] args)> >{> >int> n = 7007;> >if> (checkPalindrome(n) ==>true>) {> >Console.WriteLine(>'Yes'>);> >}> >else> {> >Console.WriteLine(>'No'>);> >}> >}> }> > // This code is contributed by phasing17> |
>
>
JavaScript
> > // JavaScript program to check if a number is Palindrome> > // Function to check Palindrome> function> checkPalindrome(n)> {> >let reverse = 0;> >let temp = n;> >while> (temp != 0) {> >reverse = (reverse * 10) + (temp % 10);> >temp = Math.floor(temp / 10);> >}> >return> (reverse == n);>// if it is true then it will return 1;> >// else if false it will return 0;> }> > // driver code> > let n = 7007;> if> (checkPalindrome(n) == 1) {> >document.write(>'Yes'>,>''>);> }> else> {> >document.write(>'No'>,>''>);> }> > > // This code is contributed by shinjanpatra> > > |
>
>Producción
Yes>
Complejidad del tiempo: O(registro10(n)) u O(Número de dígitos en un número determinado)
Espacio auxiliar : O(1) o constante
Este artículo está compilado porAshish Barnwal.