¿Cómo saber si una palabra es un palíndromo?

Una frase es un palíndromo si, después de convertir todas las letras mayúsculas en minúsculas y eliminar todos los caracteres no alfanuméricos, se lee igual hacia adelante y hacia atrás. Los caracteres alfanuméricos incluyen letras y números.

           

Dada un string se busca saber si es palíndromo, si es así, retorna true, si no, false

En el ejemplo se puede apreciar, que el valor de la primera frase, se lee igual hacia adelante y hacia atrás, en cambio, la segunda frase no.

¿Quieres aprender a identificar palíndromos? En este tutorial, te enseñaremos cómo crear un algoritmo para determinar si una palabra es un palíndromo en Java y C++. ¡Perfecto para principiantes que quieren fortalecer sus habilidades en programación!

Mejora tus habilidades en programación con este ejercicio de strings. Aprende a implementar un algoritmo eficiente para verificar si una cadena de texto es un palíndromo. Ideal para aquellos que desean profundizar en estructuras de datos y algoritmos.



¿Quieres resolver desafíos de programación de manera más eficiente? Aprender a identificar palíndromos es una habilidad fundamental. En este video, te mostraremos diferentes enfoques para implementar esta solución.

¡Descubre el mundo de los palíndromos con este tutorial! Aprende a crear algoritmos para determinar si una palabra se lee igual de izquierda a derecha que de derecha a izquierda. ¡Perfecto para aquellos que buscan poner a prueba sus habilidades en programación!

¿Quieres aprender a identificar palíndromos en Java y C++? ¡Este tutorial te enseñará todo lo que necesitas saber! #palíndromo #java #c #programación #algoritmos #estructurasDeDatos #coding

Pasos para realizar el ejercicio:
1.- Se convierte el string a minúsculas.

2.- Se inicializan dos variables, i y j con valores 0, y la longitud de la cadena menos 1. Estos serán los índices que recorrerán desde el inicio y final del string, para conocer si son las mismas letras respectivas.

3.- Se inicia el recorrido desde la posición i hasta que llegue a la posición j.

4.- Se verifica si la letra de la posición i está en el alfabeto o es un número.

5.- Si la letra en la posición i es válida, se empieza a recorrer desde la posición j hasta la posición i. Si no es válida, se avanza en uno en la posición i.

6.- Se verifica si la letra de la posición j está en el alfabeto o es un número.
   
6.1.- Si la letra en la posición j no es correcta, se resta 1 al valor de j.

6.2- Si es correcta, se valida si la letra en la posición i y j son la misma.

6.1.1.- Si son diferentes, retornamos false, porque significa que la frase no es palindroma.
        
6.1.2.- Si son iguales, se sale del ciclo.

7.-  Luego del salir de recorrer el valor de j hasta i, se le resta uno a j

8.- Se aumenta en 1 la posición de i

9.- Se terminan de recorrer los índices de i y j, ya que llegan a la misma posición, entonces se retorna true, ya que la frase es palíndroma.

Código en Java

public class Solution {
 
    public static boolean isPalindrome(String s) {
        // paso#1
        s = s.toLowerCase();
 
        // paso#2
        int i = 0;
        int j = s.length() - 1;
 
        // paso#3
        while (i < j) {
            // paso#4
            if (get(s.charAt(i))) {
                // paso#5
                while (j > i) {
                    // paso#6
                    boolean es_alfanumerico = get(s.charAt(j));
 
                    // paso#6.1
                    if (!es_alfanumerico) {
                        j--;
                    }
 
                    // paso#6.2
                    else {
                        // paso#6.2.1
                        if (s.charAt(i) != s.charAt(j)) {
                            return false;
                        }
 
        // paso#6.2.2
        if (s.charAt(i) == s.charAt(j)) {
            break;
        }
    }
                }
 
                // paso 7
                j--;
            }
 
            // paso#8
            i++;
        }
 
        // paso#9
        return true;
    }
 
    private static boolean get(char c) {
        String string = "abcdefghijklmnopqrstuvwxyz0123456789";
        return string.indexOf(c) != -1;
    }
}

Código en C++

class Solution {
public:
    bool isSameAfterReversals(int num) {
        int numeroReverso = reverseInteger(num);
        int doublenumeroReverso = reverseInteger(numeroReverso);

        return num == doublenumeroReverso;
    }

private:
    int reverseInteger(int num) {
        int numeroReverso = 0;
        int aux = num;

        while (aux > 0) {
            int nro = aux % 10;
            numeroReverso = numeroReverso * 10 + nro;
            aux /= 10;
        }

        return numeroReverso;
    }
};

Código en php

class Solution {
 
    /**
     * @param String $s
     * @return Boolean
     */
    function isPalindrome($s) {
 
        //paso#1
        $s=strtolower($s);  
        //paso#2    
        $i=0;
        $j=strlen($s)-1;
 
        //paso#3
        while($i<$j){
            //paso#4
                if($this->get($s[$i])){
                //paso#5
                while($j>$i){
                    //paso#6
                    $es_alfanumerico=$this->get($s[$j]);
 
                    //paso#6.1
                    if(!$es_alfanumerico) $j--;
 
                    //paso#6.2
                    else{
                        //paso#6.2.1
                        if($s[$i]!=$s[$j]) return false;
                        //paso#6.2.2
                        if ($s[$i]==$s[$j]) break;
                    }
                }
                //paso 7
                $j--;
            }
            //paso#8
            $i++;
        }
        //paso#9
        return true;
    }
 
    private function get($char){
        $string="abcdefghijklmnopqrstuvwxyz0123456789";
        if(strpos($string, $char) !== false) return true;
        return false;
    }
}

Código en Python

class Solution(object):
    def isPalindrome(self, s):
        """
        Checks if a string is a palindrome.
 
        Args:
            s: The string to be checked.
 
        Returns:
            True if the string is a palindrome, False otherwise.
        """
 
        # paso#1
        s = s.lower()
 
        # paso#2
        i = 0
        j = len(s) - 1
 
        # paso#3
        while i < j:
            # paso#4
            if self.get(s[i]):
                # paso#5
                while j > i:
                    # paso#6
                    is_alphanumeric = self.get(s[j])
 
                    # paso#6.1
                    if not is_alphanumeric:
                        j -= 1
 
                    # paso#6.2
                    else:
                        # paso#6.2.1
                        if s[i] != s[j]:
                            return False
 
                        # paso#6.2.2
                        if s[i] == s[j]:
                            break
 
                # paso 7
                j -= 1
 
            # paso#8
            i += 1
 
        # paso#9
        return True
 
    def get(self, char):
        string = "abcdefghijklmnopqrstuvwxyz0123456789"
        return char in string

 

 
Conclusión
 El problema de los palíndromos se puede resolver en diversos lenguajes de programación (Java, Python, C++, JavaScript), demostrando la versatilidad de estos lenguajes y la aplicabilidad de conceptos básicos a diferentes contextos.

Resolver este ejercicio ayuda a fortalecer las habilidades de programación, mejorar la lógica algorítmica y desarrollar una comprensión más profunda de las cadenas de texto.