Era facil suponer que era para un ejercicio, pero mi opinion es que es preferible poner ejercicios que si es necesario que se realicen con recursividad, para que los alumnos vayan teniendo claro y puedan distinguir cuando se debe y no se debe utilizar.
En cuanto al tema de que las maquinas de hoy son potentes es cierto, pero eso no significa que haya que tirar ciclos del reloj a la papelera haciendo cosas redundantes, por muy potentes que sean los equipos de hoy la verdad es que en muchos casos se arrastran, considero una desgracia que hoy en dia, en general, no se tenga en cuenta un poco el rendimiento del software.
Sobre todo porque en muchos casos con unas minimas modificaciones se pueden conseguir mejorar sustanciales.
Pongamos un caso practico, por ejemplo, seleccionemos ultima implementacion del algoritmo en cuestion:
Código:
function Dec2Bin(D: Integer): String;
begin
Result := '';
while D > 0 do
begin
Result := IntToStr(D mod 2) + Result;
D := D div 2;
end;
end;
Comparemosla con esta otra implementacion:
Código:
function Dec2BinEx(D: Cardinal): String;
var
P:PChar;
begin
Result:= '00000000000000000000000000000000';
P:= @Result[32];
while D > 0 do begin
P^:= PChar('01')[D AND 1];
D := D SHR 1;
Dec(P);
end;
end;
Si hacemos un test de velocidad, en un: PIV 2.4 Ghz.
La Primera implementacion:
2 millones de ejecuciones tardan aproximadamente 1 minuto.
La segunda implementacion:
2 millones de ejecuciones tardan aproximadamente 1 segundo.
Como podemos ver la diferencia es abismal de un minuto a un segundo, 60 veces mas rapido !!!.
Es decir la diferencia de velocidad es tal, que mi 486 a 50Mhz de hace 15 años usando el segundo algoritmo, es casi mas rapido que mi Pentium IV a 2.4 Gigahercios usando el algoritmo lento.
Se podria objetar que en software normal no se dan las condiciones del ejemplo, pero solo hay que pensar que precisamente para lo que se utilizan las computadoras es para realizan operaciones repetitivas sobre gran cantidad de informacion.
Si algun servidor de base de datos, por ejemplo digamos firebird o interbase, tuviese cuellos de botella en su codigo como el del ejemplo, las consultas sobre las bases de datos podrian ir 60 veces mas lentas de lo que deberian, y no es lo mismo que una consulta compleja sobre miles o millones de registros tarde 1 minuto que una hora.
Los propios componentes Indy de delphi tienes cuellos de botella de ese tipo, de modo que modificando pequeñas partes del codigo se pueden conseguir mejoras de velocidad abismales, en determinadas operaciones y situaciones.
Igualmente en los programas de mas alto nivel, digamos programas de gestion, aunque no hagan calculos complejos directamente, lo cierto es que se suele implementar pequeños algoritmos o rutinas decenas o centenares de veces a lo largo del codigo, si sumamos un pequeño retraso en cada una de las rutinas, al final tendremos retrasos y consumos de memoria apreciables.
Saludos
PD: Como ejercicio dejo la siguiente pregunta, ¿ porque la segunda implementatcion es 60 veces mas rapida que la primera
?