Hola.
Tu código
parece funcionar, pero no del todo.
Es decir, convierte la cadena correctamente. Y usa recursividad, pero en realidad no es la recursividad quién está convirtiendo la cadena. Al menos no en parte.
Llevo un rato mirando tu código, lo de usar el método replace() me tenía muy escamado.., por su forma de funcionar...
Y me ha dado por añadir a tu código un contador. Este contador cuenta (perdón por la redundancia) las veces que se itera tu método recursivo.
Es decir, cuantas veces se llama a sí mismo para lograr conseguir la tarea.
Y da un resultado muy curioso:
Fíjate, si le pasamos una cadena de un solo número, por ejemplo "0", da este resultado en pantalla:
¡¡Se repite 11 veces para convertir un solo número!!
Y si le pasamos dos números:
¡¡También 11 veces!!
Y si le pasamos 10 números:
Lo mismo, ¿probamos con 30?
¡¡También 11 veces!!
Da igual la cantidad de números que pongamos, siempre se itera 11 veces.
Sinceramente, no se explicar que mecánica está siguiendo tu método, pero lo que está claro es que la recursividad no está funcionando como debería.
Y la verdad es que me fascina
La cadena se está transformando, es cierto, pero me temo que es más gracias al método replace() que no a la recursividad que se le ha programado.
Si solo le pasamos 1 número, se ha de iterar 1 vez.
Y si le pasamos 30 números, pues se ha de iterar 30 veces.
He escrito yo otro método, donde hago uso del método subString().
Lo que hago es coger el primer carácter de la cadena con subString(0, 1).
Lo meto en un switch y evalúo si es "0", "1", etc...
En cada caso, retorno el String correspondiente "cero", "uno",... concatenandole una llamada recursiva a este método en el que le paso de nuevo la cadena, pero a partir del segundo carácter con subString(1)
Es decir, para cada llamada recursiva elimino el carácter que ya he evaluado.
Por tanto la cadena va perdiendo longitud en cada iteración, así que antes de hacer todo este proceso, siempre pregunto si la longitud de la cadena es 0, en cuyo caso retorno un String vacio sin ninguna llamada recursiva. Porque es entonces cuando la recursividad ha de terminar.
Le he añadido también un contador, así en el código podemos ver cuantas veces se itera este método y comparar con el tuyo.
Mira, este es el código, donde probaremos ambos métodos, cada uno con su contador:
Si probamos con un solo número:
Vemos que el nuevo método solo se itera 1 vez.
Con dos números:
Pues dos iteraciones, que es lo esperable.
Si directamente pasamos a 30 números:
Pues 30 iteraciones.
Queda patente que la recursividad aquí si que está funcionando como es debido.
En cualquier caso, aunque tu método no sea lo que se esperaba, oye, está muy bien haber dado con una solución, aunque no sea la correcta.
Es genial que hayas intentado y probado cosas hasta lograr algo por tu cuenta, cosa que no hacen la mayoría.
Ha pasado que tu método "engaña" je je, porque hace la conversión correctamente y entonces parece que es una solución a lo que se pide.
Pero no es así.
E insisto que me sigue teniendo fascinado, eso de que se itere siempre 11 veces, le pases 1 número o le pases 500..., tengo que seguir estudiándolo hasta entender su mecánica ja ja..
Pregunta y repregunta si algo no te ha quedado claro del método que he escrito.
Un saludo.
