Introducción

Ya comprobamos si una cadena es palíndroma o palíndromo en C#, un lenguaje de alto nivel en donde no nos importa mucho el manejo de la memoria, tenemos booleanos y funciones para cortar cadenas.

Ahora veamos lo mismo pero en el lenguaje de programación C, uno antiguo en donde ni siquiera existe un recolector de basura.

En resumen, veremos cómo:

• Comprobar si una cadena es palíndroma usando recursividad
• Usar el ciclo while para determinar si una cadena es palíndroma

Todo esto en el lenguaje ANSI C. Si no sabes lo que esto es, visita la Wikipedia.

Explicación del algoritmo

Ya sea que usemos recursión o ciclos, el algoritmo es el mismo. Si una cadena mide 1 o menos, entonces es palíndroma. Una cadena vacía y una de 1 es palíndroma. Por ejemplo, “m” se lee igual al inicio y al revés.

Pero en caso de que no mida 1, entonces comparamos el último y el primero; y avanzamos. Veamos un ejemplo pequeño con “abcba” que aunque no tiene sentido servirá.

El primer carácter es a, y el último es a. Avanzamos y cortamos la cadena. Ahora el primero es b y el último es b. Avanzamos, y ahora la cadena mide 1, por lo que se regresa verdadero y ahí termina todo.

Cuando una cadena no es palíndroma, nos daremos cuenta porque el primero y último no coincidirán. Hagamos una simulación con “abaa”.

Comparamos el primero y el último (a con a), y sí coinciden así que avanzamos. Luego comparamos b con a, y ahí ya no coinciden así que regresamos falso y termina.

Palíndromo en C usando recursividad

Primero veamos el enfoque recursivo. En este, la función se llama a sí misma y se va pasando los nuevos límites en donde compararemos.

int esPalindromoRecursivo(char * cadena, int indiceInicio, int indiceFin) {
 
    // Si llegamos hasta aquí es porque ya sólo queda un carácter,
    // y por lo tanto no se puede comparar con otro
    // Esto también comprueba si la cadena tiene uno o menos caracteres
    if (indiceInicio >= indiceFin) return 1;
 
    // Sólo para explicar la comparación que se hace
    printf("Comparando %c con %c\n", cadena[indiceInicio], cadena[indiceFin]);
 
    // Si no, entonces comparamos el primer y último carácter
    if (cadena[indiceInicio] == cadena[indiceFin]) {
        // En caso de que sí, vamos por buen camino. Ahora cortamos la cadena desde inicio + 1 hasta fin - 1
        return esPalindromoRecursivo(cadena, indiceInicio + 1, indiceFin - 1);
    } else {
        // Si no eran iguales los carácteres al inicio y fin, entonces desde ahí se termina la recursión
        // y se regresa 0
        return 0;
    }
}

Recibe 3 argumentos: la cadena, el inicio y el fin. Sólo debemos preocuparnos la primera vez, de ahí ella se encarga.

Al inicio de todo, el inicio será 0 y el fin lo que mida la cadena menos 1, recordando que los índices comienzan en 0.

Palíndromo en C con ciclo While

Este método es más corto y únicamente recibe la cadena como argumento. Él se encarga de calcular el inicio y fin:

int esPalindromoConWhile(char * cadena) {
 
    int longitud = strlen(cadena);
 
    // Cadenas de 1 o menos son, por definición, recursivas
    if (longitud <= 1) return 1;
 
    // Comenzamos en el inicio y fin de la cadena
    int inicio = 0, fin = longitud - 1;
 
 
    // Mientras el primer y último carácter sean iguales
    while (cadena[inicio] == cadena[fin]){
        // Aquí sólo resta un carácter por comparar, eso indica que SÍ es palíndroma
        if (inicio >= fin) return 1;
        // Vamos acortando la cadena
        inicio++;
        fin--;
    }
    // Si termina el ciclo y no se rompió, entonces no es palíndroma
    return 0;
}

En lugar de usar recursión, hacemos un while y dentro de él acortamos los límites de la cadena. Si ya sólo queda un carácter regresamos 1, y si no entonces en algún momento el ciclo terminará y nos regresará 0.

Probar funciones

Si no tienes idea de cómo se llama a estas funciones, no te preocupes. Aquí dejo un ejemplo en donde escaneamos una cadena del usuario e indicamos si es o no palíndroma. Por cierto, ya sé que palíndromo lleva acento pero C no es muy bueno imprimiéndolos.

int main() {
    // Una cadena para probar, la cual la da el usuario
    char cadena[50];
    printf("Escribe una cadena (de menos de 50 caracteres) y te voy a decir si es palindroma o no\n\t");
    scanf("%s", &cadena);
 
    // La recursiva necesita saber el inicio y fin al inicio
    int longitudDeCadena = strlen(cadena);
    int resultadoRecursivo = esPalindromoRecursivo(cadena, 0, longitudDeCadena - 1);
    if (resultadoRecursivo) {
        printf("De manera recursiva, '%s' es palindroma\n", cadena);
    } else {
        printf("De manera recursiva, '%s' NO es palindroma\n", cadena);
    }
 
    int resultadoConWhile = esPalindromoConWhile(cadena);
    if (resultadoConWhile) {
        printf("Usando while, '%s' es palindroma\n", cadena);
    } else {
        printf("Usando while, '%s' NO es palindroma\n", cadena);
    }
}

Por cierto, el límite de la cadena es de 50 pero puedes cambiarlo en el código.