¿Bucle recursivo o recursividad en bucle?
Como contaba en otro medium, no hay mejor manera para aprender que hacer katas. Últimamente he estado probando(me) las que propone codewars, muy interesantes porque puedes elegir el lenguaje en el que quieres programar y tu nivel, desde ejercicios para los que estamos aprendiendo hasta cosas más complejas y desafiantes para los seniors.
En este caso voy a centrarme en una kata que me va a ayudar a explicar y entender mejor las funciones recursivas y sus ventajas/desventajas/diferencias con los bucles.
La kata: Persistent Bugger
Este ejercicio nos propone escribir una función, que codewars denomina persistence, que reciba un número entero y nos devuelva su “ multiplicative persistence”, siendo esto el número de veces que hemos tenido que multiplicar los dígitos del número recibido como parámetro entre sí mismos hasta alcanzar una cifra de un solo parámetro. Por ejemplo:
39
→ 3 * 9 = 27
→ 2 * 7 = 14
→ 1 * 4 = 4
Tenemos un número de 1 solo dígito y hemos tenido que operarlo 3 vecespersistence(39) === 3;
Espera… esto es un bucle, ¿no?
Al enfrentarnos a un código que entendemos que tiene que repetir la misma operación pensamos en la iteración de ciertos mecanismos. Pero hay veces que la solución más sencilla, o menos enrevesada, es la recursividad.
La principal diferencia entre la recursividad y la iteración es que la recursividad nos permite ejecutar el mismo código dentro de un mismo método una y otra vez hasta que lleguemos a nuestra condición de salida, mientras que la iteración realiza una serie de ejecuciones sobre un código hasta alcanzar la condición verdadera.
Generalmente, cuando queremos resolver un código que debe ejecutarse varias veces para obtener como resultado el número de iteraciones que se han producido sobre ese código, como en nuestro ejemplo que no nos pide el número resultante de las operaciones sino el número de operaciones que hemos realizado hasta llegar a ese resultado, nos encontraremos ante un caso recursivo.
Nota: recursividad y bucles no son excluyentes, no hay ciertos problemas que sólo podamos atajar con recursividad o con bucles, simplemente a veces es más sencillo usar uno u otro.
Trabajando con recursividad
En la kata se nos plantean varios escenarios:
Vamos a resolverlo paso a paso.
1. Convertir el parámetro a string para poder separlo por dígitos
2. Creamos la condición de salida de la recursividad
3. Creamos la condición en caso de que el parámetro no sea de un solo dígito
Esta es la parte entretenida.
Cuando se nos pase un número con más de un dígito tenemos que multiplicar sus dígitos y obtener el número resultante de esta operación. Para ello aplicamos el método reduce que operará los dígitos que componen el parámetro, que previamente habíamos separado y almacenado en la variable numberDigits. Pero, ¿qué es ese 1 solitario de la línea 10? Ese 1 es la base con la que comienza a operar, como es una multiplicación el “elemento neutro” es el 1, ya que si pusiéramos un 0 todas nuestras multiplicaciones serían 0.
Una vez realizadas las operaciones llegamos al “generador de la recursividad”, el return de la línea 11. En este punto, volvemos a realizar el método persistence de nuestra variable result, que es el resultado de la multiplicación de los dígitos componentes del parámetro. ¿Para qué? Para que vuelva a comprobarse si ese número ya tiene un sólo dígito, y en ese caso la función acabaría, o si sigue teniendo más de un dígito y volvería a operarse hasta que fuese de un solo dígito.
Espera, otro 1 solitario por ahí, y encima… ¡se suma! Ese 1 que suma en la línea 11 es nuestro “acumulador de iteraciones”. Imaginemos un contador, en el que cada vez que hacemos ese return sumamos un 1, de manera que cada vez que se vuelve a ejecutar persistence contamos 1.
Veamos el código explicado para el caso del número 39:
