Introducción

Los palíndromos son palabras que se leen de igual manera de izquierda a derecha y de derecha a izquierda. Por ejemplo, “La ruta natural” o “Luz azul” son ejemplos de palíndromos.

Para comprobar si una oración lo es, simplemente hay que ver si al invertirla es igual que la original. Pero en este caso no podemos hacerlo así, porque tenemos que usar recursividad. Así que vamos a ver cómo comprobar si es palíndromo usando C# y recursión.

Pequeña nota: este ejemplo no remueve los espacios en blanco. Si quieres probar con una oración, remueve los espacios primero. Es decir, si quieres probar con “La ruta natural” escríbela así: “larutanatural”.

Igualmente puedes modificar el código y remover los espacios por ti mismo.

Nota: mira cómo se hace la implementación en C.

Algoritmo

La función que vamos a crear recibirá como argumento una variable de tipo String, que será la palabra en sí. Regresará un Booleano, que puede ser True o False indicando si la palabra lo es.

Paso 1: comprobar si la cadena tiene menos de dos caracteres

Primeramente veremos si la cadena está vacía o tiene sólo un carácter o letra, en caso de que sí, vamos a salir de la recursión. Ya que, por ejemplo, la letra “m” se lee de igual manera de izquierda a derecha que de derecha a izquierda y, aunque no sea una palabra, podría decirse que es un palíndromo.

Si te fijas en el ejemplo, también en este paso es cuando se puede decir que sí es palíndromo, porque es llamado con una sola letra (la “l”).

Paso 2: comparar primer y último carácter

Si la recursión no se rompió en el paso 1, vamos a comparar la primera y última letra de la cadena. Por ejemplo, si tenemos a “solos”, compararíamos la “s” (que es la primera letra) y la “s” (que es la última letra).

Si las letras no coinciden, se rompe la recursión porque desde ahí nos damos cuenta de que no es un palíndromo.

En caso de que las letras coincidan, aquí pasa la magia, y se vuelve a llamar a la recursión como el paso 3 lo detalla.

Paso 3: recursividad

Si no se rompe la recursión en el primer o segundo paso, entonces se llamará a la función de nuevo, pero no con la misma cadena de entrada, sino con el último y primer carácter.

Pongamos de ejemplo la palabra “solos” de nuevo. Al comparar el primer y último carácter el resultado es True, así que llamamos a la función de nuevo pero esta vez le pasamos “olo” (quitar primer y último). Y así hasta que se termine el ciclo.

Ejemplo

Por última vez usemos la palabra “solos” y veamos lo que pasa.

Se llama a la función con “solos”. Comprobamos si tiene menos de 2 letras. ¿Las tiene? no. Entonces comparamos la primera y última de estas. ¿Coincide? sí. Entonces llamamos a la función de nuevo con la cadena cortada.

Se llama a la función con “olo”. Comprobamos si tiene menos de 2 letras, y no es así. Así que comparamos la primera y última (“o” con “o”). Como sí coinciden, llamamos de nuevo a la función con la cadena cortada.

Finalmente llamamos al proceso con “l”. Comprobamos si tiene menos de 2 letras, y efectivamente así es. Así que aquí acaba la recursividad, y regresamos True.

Código

Una vez explicado el concepto y cómo se trabaja, aquí dejo el código

using System;

namespace App
{
    class Programa
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Introduce una palabra y te diré si es palíndroma :) ");
            String palabra = Console.ReadLine();
            if(esPalindroma(palabra)) Console.WriteLine("Es palíndroma");
         else Console.WriteLine("NO es palíndroma");
        }

        static Boolean esPalindroma(String cadena){
         Console.WriteLine("Función llamada con => " + cadena);
         if(cadena.Length < 2) return true;
         Console.WriteLine("Vamos a comparar => " + cadena[0]);
         Console.WriteLine("Con => " + cadena[cadena.Length - 1]);
         if(cadena[0] == cadena[cadena.Length - 1]) return esPalindroma(cadena.Substring(1, cadena.Length - 2));
         return false;
        }
    }
}