Una prueba de escritorio de un algoritmo, te dice donde esta tu error, ejercicio 3

Realizar una prueba de escritorio de un algoritmo implica simular su ejecución de manera manual, paso a paso, para verificar su funcionamiento y corregir posibles errores. Aquí tienes una serie de pasos que puedes seguir:

Pasos para hacer una prueba de escritorio

1. **Definir el algoritmo**:
Asegúrate de tener el algoritmo claramente definido, ya sea en pseudocódigo, diagrama de flujo o código fuente.

2. **Seleccionar datos de entrada**:
Elige un conjunto de datos de entrada que quieras utilizar para la prueba. Estos datos deben cubrir diferentes escenarios, incluyendo casos normales, límites y casos especiales.

3. **Inicializar variables**:
Anota y establece los valores iniciales de todas las variables que utilizará el algoritmo antes de comenzar la ejecución.

4. **Seguir el flujo del algoritmo**:
Comienza a ejecutar el algoritmo línea por línea, actualizando el estado de las variables y anotando cualquier cambio. Presta atención a las condiciones de control (como `if`, `for`, `while`, etc.) y a cómo afectan la ejecución.

5. **Registrar el resultado**:
Al final del algoritmo, anota el resultado obtenido. Esto puede ser el valor de una variable o el estado final de algún objeto o estructura de datos.

6. **Comparar con el resultado esperado**:
Compara el resultado obtenido con el resultado esperado. Si coinciden, el algoritmo funciona correctamente para ese conjunto de datos. Si no, anota las discrepancias para su análisis posterior.

7. **Repetir con diferentes conjuntos de datos**:
Realiza la prueba con diferentes datos de entrada para asegurarte de que el algoritmo maneja correctamente todos los casos posibles, incluyendo:
Casos normales.
Casos extremos o límites.
Casos de error o excepcionales.

8. **Analizar y documentar**:
Documenta los resultados de la prueba de escritorio, incluyendo cualquier error encontrado y cómo se resolvió. Esto te ayudará a mejorar el algoritmo o a ajustar la lógica según sea necesario.

Ejemplo práctico

Supongamos que tenemos un algoritmo que suma los números de una lista.

1. **Definición**: Sumar los elementos de la lista.
2. **Datos de entrada**: `[1, 2, 3]`
3. **Inicialización**: `suma = 0`
4. **Ejecución**:
Iteración 1: `suma = suma + 1` → `suma = 1`
Iteración 2: `suma = suma + 2` → `suma = 3`
Iteración 3: `suma = suma + 3` → `suma = 6`
5. **Resultado obtenido**: `6`
6. **Resultado esperado**: `6` (coincide)
7. **Repetir**: Probar con otras listas, como `[]` (debería dar 0) o `[0, 0, 0]` (debería dar 0).
8. **Documentar**: Anotar que el algoritmo funciona correctamente para los casos probados.

Conclusión

La prueba de escritorio es una técnica efectiva para detectar errores lógicos y asegurar que un algoritmo se comporta como se espera. Es especialmente útil en las fases iniciales del desarrollo, antes de implementar pruebas automatizadas.