Dominando la comprobación de palíndromos en Java

Introducción

En este laboratorio, aprenderemos a verificar si una cadena es un palíndromo o no en Java. Un palíndromo es una cadena que se lee igual de adelante hacia atrás y de atrás hacia adelante.

Usando dos punteros para comprobar palíndromos

El primer método que implementaremos es el enfoque de dos punteros. Crearemos un método llamado isPalindrome que toma una cadena como entrada y devuelve un valor booleano que indica si la cadena es un palíndromo o no.

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        int start = 0;
        int end = str.length() - 1;

        while (start < end) {
            char startChar = Character.toLowerCase(str.charAt(start));
            char endChar = Character.toLowerCase(str.charAt(end));

            if (startChar!= endChar) {
                return false;
            }

            start++;
            end--;
        }

        return true;
    }
}

El método isPalindrome utiliza dos punteros, start y end, que comienzan respectivamente desde el principio y el final de la cadena. El bucle se ejecuta hasta que los dos punteros se encuentren en el medio.

En cada iteración, comparamos los caracteres en los punteros start y end. Si no son iguales, devolvemos false. Si lo son, actualizamos los punteros para comprobar el siguiente conjunto de caracteres en la cadena.

Para probar nuestro método, podemos agregar un método principal y llamar al método isPalindrome con varias cadenas de entrada.

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        // Implementación del método isPalindrome
    }

    public static void main(String[] args) {
        System.out.println("¿Es 'racecar' un palíndromo? " + isPalindrome("racecar"));
        System.out.println("¿Es 'hello' un palíndromo? " + isPalindrome("hello"));
    }
}

Usando recursión para comprobar palíndromos

El siguiente método que implementaremos es el enfoque recursivo. Crearemos un nuevo método llamado isPalindromeRecursive que toma la cadena, el índice de inicio y el índice de fin como entrada.

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        String lowercaseStr = str.toLowerCase();
        return isPalindromeRecursive(lowercaseStr, 0, lowercaseStr.length() - 1);
    }

    public static boolean isPalindromeRecursive(String str, int start, int end) {
        if(start >= end) {
            return true;
        }

        char startChar = Character.toLowerCase(str.charAt(start));
        char endChar = Character.toLowerCase(str.charAt(end));

        if(startChar!= endChar) {
            return false;
        }

        return isPalindromeRecursive(str, start + 1, end - 1);
    }

    public static void main(String[] args) {
        // Tests for isPalindrome and isPalindromeRecursive methods
    }
}

El método isPalindromeRecursive utiliza recursión para comprobar si la cadena es un palíndromo o no. Tenemos dos casos base:

Si el índice start es mayor o igual que el índice end, significa que hemos comprobado todos los caracteres de la cadena y coinciden, entonces devolvemos true.
Si los caracteres en los índices start y end no son iguales, devolvemos false.

Si ninguno de los casos base se cumple, llamamos a isPalindromeRecursive nuevamente con los índices actualizados.

Ahora podemos probar nuestro método recursivo llamándolo dentro del método main.

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        // Implementación del método isPalindrome
    }

    public static boolean isPalindromeRecursive(String str, int start, int end) {
        // Implementación del método isPalindromeRecursive
    }

    public static void main(String[] args) {
        System.out.println("¿Es 'racecar' un palíndromo? " + isPalindromeRecursive("racecar", 0, 6));
        System.out.println("¿Es 'hello' un palíndromo? " + isPalindromeRecursive("hello", 0, 4));
    }
}

Volteando la cadena para comprobar palíndromos

El último método que implementaremos es el enfoque de voltear la cadena. Crearemos un nuevo método llamado isPalindromeReverse que toma una cadena como entrada.

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        // Implementación del método isPalindrome
    }

    public static boolean isPalindromeRecursive(String str, int start, int end) {
        // Implementación del método isPalindromeRecursive
    }

    public static boolean isPalindromeReverse(String str) {
        String reversed = "";

        for (int i = str.length() - 1; i >= 0; i--) {
            reversed += str.charAt(i);
        }

        return str.equalsIgnoreCase(reversed);
    }

    public static void main(String[] args) {
        // Tests for isPalindrome and isPalindromeRecursive methods
        System.out.println("¿Es 'racecar' un palíndromo? " + isPalindromeReverse("racecar"));
        System.out.println("¿Es 'hello' un palíndromo? " + isPalindromeReverse("hello"));
    }
}

El método isPalindromeReverse crea una nueva cadena llamada reversed y la llena iterando a través de la cadena de entrada desde el final hasta el principio. Luego devolvemos true si las dos cadenas son iguales ignorando mayúsculas y minúsculas.

Podemos probar el método agregando una llamada a isPalindromeReverse en el método main.

Usando flujos de Java para comprobar palíndromos

Finalmente, usaremos la API de Java Streams para comprobar palíndromos. Crearemos un nuevo método llamado isPalindromeStream que toma una cadena como entrada.

import java.util.stream.IntStream;

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        // Implementación del método isPalindrome
    }

    public static boolean isPalindromeRecursive(String str, int start, int end) {
        // Implementación del método isPalindromeRecursive
    }

    public static boolean isPalindromeReverse(String str) {
        // Implementación del método isPalindromeReverse
    }

    public static boolean isPalindromeStream(String str) {
        String lowercaseStr = str.toLowerCase();

        return IntStream.range(0, lowercaseStr.length() / 2)
             .noneMatch(i -> lowercaseStr.charAt(i)!= lowercaseStr.charAt(lowercaseStr.length() - i - 1));
    }

    public static void main(String[] args) {
        // Tests for isPalindrome and isPalindromeRecursive methods
        System.out.println("¿Es 'racecar' un palíndromo? " + isPalindromeStream("racecar"));
        System.out.println("¿Es 'hello' a palindrome? " + isPalindromeStream("hello"));
    }
}

El método isPalindromeStream utiliza la clase IntStream para generar un rango de índices que podemos usar para comparar los caracteres en la cadena.

Usamos el método noneMatch para devolver true si ninguno de los caracteres viola la condición de que el ith y el n - i - 1th caracteres son iguales, donde n es la longitud de la cadena y i es el índice.

Podemos probar el método agregando una llamada a isPalindromeStream en el método main.

Resumen

En este laboratorio, aprendimos cómo comprobar si una cadena dada es un palíndromo o no en Java. Implementamos cuatro métodos diferentes para realizar esta tarea:

Enfoque de dos punteros
Enfoque recursivo
Enfoque de voltear la cadena
Enfoque de Java Streams

Ahora que entiendes estos métodos, ¡puedes utilizarlos para resolver problemas más complejos!

Comprobando palíndromos en Java