PIlas

En base a lo que te contesté antes, te diría que primero, antes que pensar en la recursividad, pienses en los pequeños problemas. Por ejemplo:
1) Tenemos 10 números (0.. 9). Necesitamos algún medio para que dado un número nos retorne las posibles letras por las que se reemplaza.
Pensemos opciones:
- Una función que dado un número me retorne la lista de letras.
- Alguna implementación con un Array.
RESULTADO: yo particularmente me quedo con la segunda.
LETRAS = Array [0..9] of String[3];
Lo que esto dice es que hay 10 teclas y por cada una un máximo de 3 letras. Obviamente falta inicializar cada tecla.
¿Por qué un String[3]?, bueno es un medio que me permite variar entre 0 y 3 letras sin tener que escribir una línea código. Así, si una tecla no tiene letras se le pone '', mientras que al 2 le corresponde 'abc' y así.
2) No creo que haga falta nada más a modo de subproblema por ahora.
Programa FINAL:
Siempre tenés que pensar en lo que querés como resultado. Identificar pequeños problemas y resolverlos. Una vez que tenés las pequeñas cosas podes empezar a crear para arriba.
Yo me imagino el problema como un listado donde se imprime en cada renglón una combinación distinta y al final cuenta la cantidad de combinaciones.
De momento lo que resolvería el problema (a primera vista), sería una función que, dado un número, me imprima las combinaciones posibles y devuelva la cantidad de combinaciones encontradas.
function Combinaciones(num : String) : Integer
Ahora bien, sabemos que tenemos que recorrer todo el string. Intuitivamente pensamos en un FOR de este tipo
FOR i := 1 TO length(num) DO
Pero si te ponés a pensar un poco vas a ver que lo que sigue es complicado. Bastante más complicado si lo pensamos en términos de iteraciones anidadas. Tratá de hacer una solución con For, while y repeat anidados y me contás.
Sin embargo podemos pensarlo recursivamente. Para ello tenemos que determinar un patrón de recursión. En este caso podríamos hacer recursión en el número de elementos como habíamos pensado originalmente. Como es en el NÚMERO tenemos dos casos a considerar:
- El caso de la longitud 0
- El caso de la longitud n > 0
Fíjate
Supongamos que el string es '':
function Combinaciones (num : String) : Integer;
begin
if length(num) = 0 then
Combinaciones := 0
else {lo que venga cuando n > 0}
end;
Ahora pensemos en el tema de la recursión. Generalmente pensamos en cómo resolver el caso inmediatamente siguiente al caso base. En este caso, el de longitud 1. Por ejemplo el String '2':
function Combinaciones (num : String) : Integer;
VAR i : Integer;
begin
if length(num) = 0 then
Combinaciones := 0
else begin
FOR i := 1 TO length(LETRAS[XXXXXXXXX]) DO BEGIN
Write(LETRAS);
INC(Combinaciones);
END;
end;
end;
Acá hacemos la primer modificación. Las XXX son el índice al que corresponde el número que me dan como parámetro. El índice es INTEGER y el dígito que analizamos es CHAR. O adaptamos el CHAR a un INTEGER o a la inversa. Nuevamente tomo la segunda opción y redefino LETRAS para que sea todo más rápido:
LETRAS = Array ['0'..'9'] of String[3];
Ahora sí:
function Combinaciones (num : String) : Integer;
VAR i : Integer;
begin
if length(num) = 0 then
Combinaciones := 0
else begin
FOR i := 1 TO length(LETRAS[num[1]]) DO BEGIN
Write(LETRAS);
INC(Combinaciones);
END;
end;
end;
Fijate que como te dije sólo analizamos el primer número, por eso puse num[1] en el FOR.
Ahora falta ubicar la recursión. Como ya resolvimos el tema de un dígito, lo que nos queda es concatenar el primer dígito con lo que resulta de los siguientes y lo hacemos literalmente:
function Combinaciones (num : String) : Integer;
VAR i : Integer;
begin
if length(num) = 0 then
Combinaciones := 0
else begin
Combinaciones := 0;
FOR i := 1 TO length(LETRAS[num[1]]) DO BEGIN
Write(LETRAS);
Combinaciones := Combinaciones + Combinaciones(Copy(num,2,length(num));
END;
end;
end;
Lo anterior ya es un ejercicio resuelto. Pero podemos optimizarlo un poco y emprolijar el formato de la salida:
function Combinaciones (num : String) : Integer;
VAR i : Integer;
begin
Combinaciones := 0
if length(num) = 0 then
WriteLn;
else begin
FOR i := 1 TO length(LETRAS[num[1]]) DO BEGIN
Write(LETRAS);
Combinaciones := Combinaciones + Combinaciones(Copy(num,2,length(num));
END;
end;
end;
Para terminar, acordate que LETRAS['0']='0' y LETRAS['1']='1'.