¿Cómo saber si un número es palíndromo o capicúa?

¿Alguna vez te has preguntado si un número es palíndromo? Un número palíndromo es un número que se lee igual de izquierda a derecha que de derecha a izquierda. Por ejemplo, 121, 1001 y 929 son números palíndromos.

En este blog, te enseñaremos cómo saber si un número es palíndromo en Java, Python, PHP, C++ y JavaScript.

El algoritmo a realizar consiste en revertir el número y compararlo con el número original. Si los dos números son iguales, entonces el número original es un palíndromo.

Para este ejercicio, vamos a verificar si un número es palíndromo y como condición particular no vamos a convertir los integer en strings.

                       

Ejercicio de integers #1: ¿Cómo saber si un número es palíndromo o capicúa?. ¿Quieres aprender a identificar números palíndromos? En este tutorial, te enseñaré paso a paso cómo crear un algoritmo para determinar si un número es palíndromo o capicúa. ¡Perfecto para principiantes en programación y para prepararte para entrevistas técnicas!

Mejora tus habilidades en programación con este ejercicio de números palíndromos. Exploraremos diferentes enfoques para resolver este problema clásico de algoritmos y estructuras de datos. Ideal para estudiantes, programadores autodidactas y aquellos que se preparan para entrevistas técnicas en empresas tecnológicas.

¿Quieres dominar los conceptos básicos de programación? Resolver el problema de los números palíndromos es una excelente manera de practicar algoritmos y lógica de programación. En este video, te mostraré cómo implementar una solución eficiente en diferentes lenguajes de programación.



¡Descubre la magia de los números palíndromos! Aprende a construir algoritmos que identifiquen estos números especiales y mejora tus habilidades de resolución de problemas. ¡Perfecto para programadores de todos los niveles que buscan un desafío divertido!

¿Quieres aprender a identificar números palíndromos? ¡Este tutorial te enseñará cómo crear un algoritmo eficiente! #Palindromo #EjerciciodeEnteros #algoritmos #programación #coding #entrevistaTecnica #VenezuelaPrograma
  
Pasos para realizar el ejercicio:
1.-Declarar las variables invertido y aux.

✅La variable invertido almacenará el número invertido y se inicia en 0.

✅La variable aux almacenará el número original.
        
2.- Se  recorre el número original mientras sea mayor que 0.
En cada iteración se obtiene el último dígito del número original y se almacena en la variable val, utilizando el operador módulo (%).

3.- Se agrega el último dígito al número invertido. Esto se hace multiplicando el número invertido actual por 10 y sumándolo con la variable val
        
4.-Se divide el número original entre 10.
Esto elimina su último dígito.

5.- Una vez que se termina el ciclo, la función devuelve true si el número invertido es igual al valor de la variable aux, en caso contrario, devuelve false.

Código en Java

class Solution {
 
    /**
     * @param Integer $x
     * @return Boolean
     */
    public static boolean isPalindrome(int original) {
        //paso#1
        int invertido = 0;
        int aux = original;
 
       //paso#2
        while (original > 0) {
            int val = original % 10;
 
            //paso#3
            invertido = val + (invertido * 10);
            //paso#4
            original = original / 10;
        }
 
        //paso#5
        return invertido == aux;
    }
}

Código en php

class Solution {
 
    /**
     * @param Integer $x
     * @return Boolean
     */
    function isPalindrome($x) {
        //paso#1
        $revertido=0;
        $aux = $x;
 
        while($aux>0){
            //paso#2
            $val = $aux %10;
            //paso#3
            $revertido = $val + ($revertido * 10) ;
            //paso#4
            $aux = floor($aux/10);
        }
 
        //paso#5
        if($revertido == $x) return true;
        else return false;
 
    }
}

Código en Python

class Solution(object):
    def isPalindrome(self, x):
        #paso#1
        invertido = 0
        aux = x
 
        #paso#2
        while aux > 0:
            #paso#3
            val = aux % 10
            #paso#4
            invertido = val + (invertido * 10)
            #paso#5
            aux = aux // 10
 
        #paso#6
        return invertido == x 

Código en C++

class Solution {
public:
    /**
     * @param Integer $x
     * @return Boolean
     */
    bool isPalindrome(int x) {
        //paso#1
        long long int invertido = 0;
        int aux = x;
 
        //paso#2
        while (aux > 0) {
            //paso#3
            int val = aux % 10;
            //paso#4
            invertido = val + (invertido * 10);
            //paso#5
            aux = aux / 10;
        }
 
        //paso#6
        if(invertido == x) return true;
        return false;
    }
}; 

Código en JavaScript

/**
    * @param {number} x
    * @return {boolean}
    */
   var isPalindrome = function(x) {
       //paso#1
       let invertido = 0;
       let aux = x;
    
       while (aux > 0) {
           //paso#2
           let val = aux % 10;
           //paso#3
           invertido = val + (invertido * 10);
           //paso#4
           aux = Math.floor(aux / 10);
       }
    
       //paso#5
       if(invertido == x) return true;
       return false;
   };

        
    
Conclusión
En este blog, hemos visto cómo saber si un número es palíndromo en Java, Python, PHP, C++ y JavaScript.

Hemos visto ejemplos de código para cada método en cada lenguaje de programación.