Paso 6 de cómo hacer un algoritmo

El paso 6 de cómo hacer un algoritmo indica:

Ejecutar a mano (en el papel) nuestro algoritmo y corregir los errores.

Al "terminar" de detallar nuestro algoritmo (paso 5 de cómo hacer un algoritmo), es necesario que verifiquemos que está completo y es correcto. La forma de hacer esto es simulando la ejecución del algoritmo llevando un registro de las entradas, salidas, valores que contienen nuestras variables y el flujo de la ejecución.

Por ejemplo, dado el siguiente ejemplo (muy sencillo) de un algoritmo para efectuar la suma de dos números:

1- Mostrar el mensaje "Ingresa un número"
2- Leer el dato ingresado y guardarlo en la variable num1
3- Mostrar el mensaje "Ingresa otro número"
4- Leer el dato ingresado y guardarlo en la variable num2
5- Sumar los dos números y colocar el resultado en la variable suma
6- Mostrar en pantalla el mensaje "La suma de los dos números es ", y mostrar el resultado de la suma

Podemos llevar la siguiente "ejecución" de nuestro algoritmo (comenzando con el paso 1)

Paso actual: 1
Salida actual:
Ingresa un número

Después "ejecutamos" el segundo paso:

Paso actual: 2
num1 = 1234
Salida actual:
Ingresa un número
1234

Nótese que en la sección donde se simula la salida también anotamos lo que el usuario podría teclear (en este caso, teclearía "1234"). Ese valor que ingresó el usuario es colocado en la variable llamada "num1", por ello también registramos que ya tenemos una variable con ese nombre y que su valor actual es "1234".

A continuación ejecutamos el paso 3 y 4, donde registramos una nueva variable (num2) y el valor que debe almacenar.

Paso actual: 4
num1 = 1234
num2 = 345
Salida actual:
Ingresa un número
1234
Ingresa otro número
345

Ahora "ejecutamos" el paso 5.

Paso actual: 5
num1 = 1234
num2 = 345
suma = 1579
Salida actual:
Ingresa un número
1234
Ingresa otro número
345

Y por último ejecutamos el paso 6.

Paso actual: 6
num1 = 1234
num2 = 345
suma = 1579
Salida actual:
Ingresa un número
1234
Ingresa otro número
345
La suma de los dos números es 1579

Ventajas

Hacer la simulación de la ejecución del algoritmo de esta manera nos da estas ventajas:

1- Tenemos registrada la ejecución a lo largo del tiempo. Así que podemos entender el comportamiento real del algoritmo. 2- Podemos llevar el registro de cómo han cambiado los valores que tienen nuestras variables. Para ello, si registramos en papel la ejecución de nuestro programa, al cambiar el valor de una variable podemos tachar el valor antiguo y anotamos el nuevo valor. Por ejemplo:

Paso actual: 130 contador = 1,2,3,4,5,6,7

Identificación de errores

Al ejecutar el algoritmo de forma manual debemos tener en cuenta que debemos ejecutar lo que el algoritmo dice, no lo que se supone debe hacer.

Esto es muy importante ya que al ejecutar el algoritmo de forma manual y con cuidado deberemos ser capaces de identificar errores sutiles que son difíciles de ver.

Por ejemplo, supongamos que tenemos el siguiente fragmento de un algoritmo:

39- Sacar el promedio de los 3 números al sumar los 3 números y dividirlo entre 3, y el resultado de esa operación lo guardamos en una variable.
39.1-  promedio <--  numero1 + numero2 + numero3 / 3

En el paso 39 describimos qué es lo que se supone el algoritmo debe hacer, mientras que en el paso 39.1 especificamos cómo se lleva a cabo.

Si nosotros ejecutamos lo que se supone que el algoritmo debe hacer y no ejecutamos los pasos documentados de cómo se lleva a cabo se nos escapará que el paso 39.1 es incorrecto.

El error está en que, dada la precedencia de los operadores, primero se ejecutará la división de la variable "numero3" entre 3, y después se le sumarán los valores de las variables "numero1" y "numero2", lo cual da un resultado incorrecto.

Una vez que ejecutamos lo que el algoritmo dice (no lo que se supone debe hacer), tendremos la información necesaria para corregir nuestro algoritmo y continuar probándolo, quedando ese fragmento como:

39- Sacar el promedio de los 3 números al sumar los 3 números y dividirlo entre 3, y el resultado de esa operación lo guardamos en una variable.
39.1-  promedio <--  (numero1 + numero2 + numero3) / 3

En esta versión corregida actualizamos la fórmula en el algoritmo para establecer que primero se debe hacer la suma de los 3 números y por último se deberá hacer la división entre 3.

La ejecución manual de nuestro algoritmo lo deberemos hacer varias veces, con datos de entrada de ejemplo tales que sabremos de antemano qué salida debe darnos.

Solamente cuando la ejecución de todos esos casos de prueba nos dan el resultado de salida correcto podremos decir que nuestro algoritmo (aparentemente) está correcto. Y digo que "aparentemente" está correcto debido a que, dependiendo de la complejidad del mismo, quizás no lo hayamos probado de manera exaustiva, o que quizás no hayamos podido anotar todas las posibilidades y caminos alternativos que podría nuestro algoritmo tomar. Sin embargo, sí podemos asegurar que tenemos un algoritmo "sólido" a comparación de no haberlo tenido.

Paso 5 de cómo hacer un algoritmo

El paso 5 de cómo hacer un algoritmo indica Repetir los pasos 3 y 4 hasta que esté "lo suficientemente detallado"

Lograr tener un algoritmo para un proceso que no sea trivial no es fácil. Es necesario trabajar con él, leerlo, refinarlo, identificar y corregir los posibles errores, todo esto a través de la repetición de los pasos 3 y 4 de cómo se hace un algoritmo.

Recordemos que los pasos 3 y 4 básicamente nos dicen que hay que leer los pasos actuales con la finalidad de identificar nuevos datos, nueva información que antes se nos haya pasado, y detallar "un poco más" esos mismos pasos con la finalidad de ser más claros y con ello acercarnos a la versión final.

En cada iteración nuestro algoritmo debe mejorar. En cada iteración deben haber cambios en la redacción de los pasos que, al leerlos, nos de la impresión de que hubo mejora; y el proceso de mejora termina cuando consideramos que no tenemos una forma diferente de describirlo, o que en realidad es tan claro que no debemos continuar detallando.

No hay una cantidad mínima ni máxima de iteraciones. Solamente debemos tener en cuenta que si no lo tenemos lo suficientemente detallado, al ejecutar el algoritmo, o al intentar codificarlo en algún lenguaje de programación podremos llegar a toparnos con problemas que debimos haber previsto y para los cuales debiéramos estar preparados, y no lo hicimos, y no estamos preparados.

Paso 4 de cómo hacer un algoritmo

El paso 4 de cómo hacer un algoritmo dice es Detallar "un poco más" cada uno de los pasos de nuestro algoritmo actual.

La creación de un algoritmo es un proceso evolutivo. Es un proceso en el que, poco a poco, cada uno de los pasos que actualmente tenemos documentados van perdiendo la ambigüedad propia de nuestro lenguaje natural (con el cual comenzamos a escribirlo).

Quitar la ambigüedad de esos pasos conlleva a analizar el objetivo que se desea alcanzar, realizar las acciones de forma manual e identificar esa toma de decisiones y pasos intermedios que llevamos a cabo y que quizás pasamos por alto. Esto, con la finalidad de anotarlos y que queden explícitos.

Tomemos el siguiente ejemplo, dados los pasos:

  1. Leer 3 calificaciones de un alumno
  2. Calcular el promedio
  3. Mostrar el resultado.

El primer paso puede detallarse a los siguientes:

1.1 Solicitar la primera calificación. 1.2 Leer la primera calificación. 1.3 Solicitar la segunda calificación. 1.4 Leer la segunda calificación. 1.5 Solicitar la tercera calificación. 1.6 Leer la tercera calfiicación.

El segundo paso puede detallarse como:

2.1 Sumar las 3 calificaciones 2.2 Dividir la suma de las calificaciones entre 3

El tercer paso puede detallarse de la siguiente manera:

3.1 Mostrar mensaje de agradecimiento al usuario por usar nuestro programa 3.2 Mostar al usuario el resultado calculado 3.3 Mostrar al usuario un mensaje invitándolo a seguirlo usando.

He explicado que esos pasos originales PUEDEN ser detallados tal y como lo indiqué. No es una obligación y cada persona puede describir los nuevos pasos con las palabras y terminologías que desee. Incluso, si ya se cuenta con algo muy específico (por ejemplo, en el paso 2), se puede indicar la fórmula que se utilizaría. Por ejemplo

2.1 promedio <---- (calificacion1, calificacion2, ...., calificacionN) / N

En algunas ocasiones, definir de manera detallada los pasos requiere que nosotros tomemos papel y lápiz, hagamos a mano el proceso que deseamos detallar y siguiendo las acciones que vamos haciendo expresarlas con palabras.

Por ejemplo, para el paso a detallar

49- Insertar un número en la lista enlazada

Después de simular a mano, en papel, el proceso de inserción de un nuevo nodo en una lista enlazada, los nuevo pasos detallados podría quedar:

49.1 Localizar el nodo inmediato anterior a donde se debe insertar el nuevo nodo 49.2 El apuntador al siguiente nodo (en el nuevo nodo) hacer que apunte al nodo siguiente al que localizamos previamente 49.3 Hacer que el nodo localizado apunte en el nuevo nodo.

Por último debemos asegurarnos que, en lo posible, el conjunto de nuevos pasos llenen a cabalidad la descripción del paso original.

Digo que en lo posible, porque es posible que al estar haciendo el análisis nos demos cuenta de que algunas cosas descritas en el paso original no deben ser resueltas en los nuevos pasos sino en algún otro lugar.es decir, nuestro algoritmo va a ir evolucionando en cada iteración y durante esas mejoras nos toparemos con cosas nuevas y cosas que deberemos cambiar.

Paso 3 de cómo hacer un algoritmo

Cuando estamos intentando crear un algoritmo (para posteriormente escribir un programa de computadora), comenzamos por una versión inicial sin detalles que poco a poco vamos refinando.

Esas versiones incompletas son analizadas y revisadas para identificar en ellas la información que debe ser procesada, las operaciones que son efectuadas y los nuevos datos que vamos a obtener con el proceso.

Es por ello que, de cada uno de los pasos que tenemos actualmente escritos de nuestro algoritmo debemos identificar: 1. Variables 2. Constantes 3. Tipos de datos 4. Fórmulas 5. Límites y restricciones

Por ejemplo, dados los siguientes pasos de la creación en progreso de un algoritmo:

  1. Pedir 3 calificaciones
  2. Calcular su promedio
  3. Mostrar al usuario el promedio calculado

Al leer esos pasos y estudiarlos un poco podemos identificar lo siguiente:

Variables

Encontramos 3 variables para almacenar las 3 calificaciones, al igual que una variable para almacenar el resultado del cálculo del promedio.

Establezcamos (y anotemos en papel) los nombres de estas variables como:

calificacion_1, calificacion_2, calificacion_3 y promedio_calificaciones

Constantes

De nuestros pasos también identificamos que existe un valor constante (por lo pronto es constante ya que más adelante podría ser una variable), y este valor es el 3, el cual corresponde al número total de calificaciones que estaremos procesando, por lo cual también lo anotaremos.

CANTIDAD_TOTAL_CALIFICACIONES = 3

Aún y cuando los pasos no lo indican, podríamos intuir que en el paso 1, Pedir 3 calificaciones, requeriremos mostrar al usuario un mensaje solicitando al usuario que ingrese el valor de una calificación. Es necesario que vayamos registrando cualquier texto o mensaje que identifiquemos que pueda ser usado en el programa. De esta manera, estos mensajes podrán ser validados junto con el cliente para establecer que son correctos, no tienen faltas de ortografía, usan un lenguaje adecuado y son claros.

Por ejemplo, podríamos establecer que en nuestro algoritmo se requieren constantes de cadena de caracteres para solicitar que el usuario ingrese un valor y para que le de a conocer al usuario el resultado del cálculo del promedio, los cuales podrían ser:

MSG_PETICION = " Por favor, introduzca el valor de la calificación" MSG_RESULTADO="El promedio final del alumno es"

En otros casos podríamos identificar constantes como IVA, IMPUESTO, y COMISIÓN_DEL_VENDEDOR.

Tipos de datos

Al identificar nuestras variables y constantes también debemos identificar a qué tipos de datos se refieren. Por ejemplo:

calificacion_1, calificacion_2, calificacion_3, promedio_calificaciones : Tipo numérico.

O incluso, aún ser más específicos:

calificacion_1, calificacion_2, calificacion_3 : Numéricos enteros promedio_calificaciones: Numérico con punto decimal

Esto se vuelve muy importante cuando estamos trabajando con sistemas más complejos que los que se escriben en estos ejemplos. Por ejemplo, podríamos identificar la necesidad de contar con tipos de datos creados por el usuario en el caso de que no existan, o de nuevas clases (en términos de programación orientada a objetos) que guarden información relacionada entre sí bajo un nuevo nombre.

Algunos ejemplos de tipos de datos que podríamos identificar son proxies, daos, gateways, coordenadas, canvas, ventanas, botones, usuarios, por nombrar tan solo unos pocos.

Fórmulas

Tenemos identificados los datos y las constantes, sabemos que debemos procesarlos y por ello debemos identificar las fórmulas requeridas para su procesamiento. En nuestro caso, la fórmula que debemos utilizar es:

El promedio de 3 números se obtiene al sumar los 3 números y posteriormente dividir el resultado de la suma entre 3.

Dependiendo del dominio del problema se deberán investigar las fórmulas necesarias y escribir esas fórmulas para poder validar (con algún experto o algún libro) que, en efecto, la fórmula que pensamos aplicar en nuestro algoritmo nos da el resultado buscado.

Límites y restricciones

Aprovechando el análisis que llevamos de los pasos actuales en nuestro algoritmo, podemos identificar también cualquier límite y restricción que debemos tomar en cuenta al momento de procesar los datos. Muchas veces esos límites y restricciones se pueden documentar como constantes. Por ejemplo:

VALOR_MINIMO_CALIFICACION = 0 VALOR_MAXIMO_CALIFICACION=10 CANTIDAD_INVALIDA_CALIFICACIONES=0

Explicando brevemente: 1. Supondremos que no se pueden tener calificaciones negativas, por lo cual el valor mínimo de luna calificación es el 0. 2. De la misma manera, estamos suponiendo que valor máximo que se puede dar a una calificación es 10. 3. No se puede dividir entre cero, por lo cual, para poder aplicar la fórmula matemática para calcular un promedio, el cero es un valor inválido como denominador en la división.

Paso 2 de cómo hacer un algoritmo

Una vez que estamos seguros de entender un problema, después de analizarlo y poder contestar con un "Sí" todas las preguntas del primer paso de cómo escribir un algoritmo, podremos ejecutar el segundo paso, el cual consiste en:

Escribir "a grosso modo" (sin detalles) los pasos que se deben ejecutar para solucionar el problema.

En casos sencillos, tan solo se necesitan escribir los requerimientos como una serie de pasos. Por ejemplo, para el requerimiento:

Hacer un programa que lea 3 calificaciones de un alumno, calcule su promedio y muestre el resultado.

La versión inicial del algoritmo podría ser:

  1. Leer 3 calificaciones de un alumno
  2. Calcular el promedio
  3. Mostrar el resultado.

Aquí es importante notar lo siguiente: la mayoría de los problemas de los cuales necesitamos hacer un algoritmo se pueden escribir inicialmente con estos tres pasos. 1. Leer datos (realizar una operación de entrada) 2. Procesar los datos 3. Mostrar el resultado (realizar una operación de salida)

Por último, también se debe notar que estos primeros pasos de nuestra versión inicial del algoritmo, no tienen detalles, están escritos en un lenguaje coloquial (no en un lenguaje de programación) y en su conjunto (si se leé de inicio a fin) deben sonar lógicos y aparentemente al llevarlos a cabo podrían llegar a un resultado correcto.

En este paso inicial no debemos preocuparnos por si hay ambigüedades, por si no detalla aspectos específicos en algún paradigma o lenguaje de programación. Lo que nos interesa es tener un punto de partida, un mapa inicial que nos guiará a tener un algoritmo correcto.

Paso 1 de cómo hacer un algoritmo

Cuando he preguntado a los programadores cómo se hace un algoritmo, normalmente me indican:

Primero tienes que analizar el problema.

Esto es definitivamente correcto, solamente queda la pregunta ¿Cómo se analiza un problema? o ¿a qué se refieren con analizar el problema?. La respuesta no es tan sencilla ya que esa actividad varía a partir del conocimiento previo que tenemos del problema. ¿Conocemos poco? entonces hay que investigar más. ¿Conocemos mucho? entonces probablemente solo requerimos poca información.

No se puede hacer un algoritmo (describir los pasos para dar la solución a un problema) si nosotros no sabemos cómo se soluciona el problema. Y sin embargo, aunque resulte increíble, algunos programadores (principiantes o estudiantes, principalmente) tienden a ir directamente a la computadora a escribir código para un programa que aún ni ellos mismos saben cómo se resuelve; sin saber la solución al problema al que se enfrentan.

Estaremos listos para escribir el algoritmo cuando respondemos con un SÍ a todas las siguientes preguntas.

¿Entiendo de qué trata el problema?

Por ejemplo, si el problema (o el programa que hay que escribir) dice:

Se requiere de un programa que lea las 3 calificaciones de un estudiante, calcule el promedio de sus calificaciones y muestre al usuario el promedio calculado.

Probablemente todo mundo que lo lea lo podrá entender. Pero, por otro lado, si el problema indica:

Crear un programa que calcule el sistema sistomorfomológico cautivo de tres incidencias usando la fórmula isomonotrópica lateral de Mistuv-Jenter con 2 grados de ocupación negativa y 3 positivas.

Quizás nadie sabrá de qué trata el asunto, por lo cual hay que investigar, leer, preguntar, documentarse, ver ejemplos. A estas actividades son a las que en conjunto se llama "analizar el problema".

Si no entendemos el problema, si no sabemos de qué trata, es totalmente inútil sentarse a escribir código esperando que, de alguna forma o por inspiración divina surja mágicamente la solución. Si no se entiende el problema hay que investigar y preguntar hasta entenderlo (no digo dominarlo) sino entenderlo.

¿Sé cómo se hace? ¿puedo hacerlo yo mismo?

Recordemos que hacer el algoritmo para un programa es escribir los pasos que se deben llevar a cabo. No podemos escribir la solución de un problema si nosotros mismos desconocemos cómo es la solución. Por ejemplo, para el problema:

Crear un programa que, sin usar ninguna función matemática existente más que operaciones de sumas, restas multiplicaciones y divisiones, calcule la raíz cúbica de un número dado.

Puede ser que yo sepa qué significa sacar la raíz cúbica de un número, pero que nunca lo haya hecho a mano, y que por lo tanto, no puedo decirle a la computadora cómo debe ejecutarlo.

Para escribir un algoritmo, no basta con entender un problema. Nosotros mismos debemos conocer cómo se soluciona y los pasos que se deben seguir. De otra manera no podremos poner por escrito qué acciones se requieren realizar (y en qué orden, y qué hacer ante situaciones específicas) para solucionar un problema.

¿Puedo identificar un resultado correcto de uno incorrecto?

Muchas veces nosotros podemos seguir al pie de la letra una serie de pasos y tener un resultado. Sin embargo, tener un resultado (cualquiera que sea) no nos asegura que sea un resultado correcto.

Por ejemplo, si requiero sacar la raíz cúbica del número 27 y sigo una serie de pasos que me aseguran que con ellos obtendré la raíz, si al finalizar los pasos tengo como resultado el valor -1, debo saber que ese resultado obtenido, aunque sea numérico, no es correcto. Es por ello que es conveniente tener a la mano un conjunto de datos de prueba que podremos utilizar al probar nuestro algoritmo y con ello confirmar (o rechazar en su caso) la validez de nuestro algoritmo.

Creación de Algoritmos

Definición de algoritmo

Algoritmo: Conjunto de pasos ordenados, finitos, sin ambigüedades que conllevan a la solución de un problema.

La definición anterior es simple de entender, pero creo que lo que es difícil de describir es cómo hacer un algoritmo, por lo cual muchos programadores no los hacen, solamente se dedican a programar atacando directamente los problemas con código en algún lenguaje de programación.

Es importante que ante todo problema de programación que tenemos que desarrollar, primero debemos tener un análisis y diseño de la solución.

Por ello, considero que saltarse la actividad de hacer algoritmos antes de sentarse a escribir código es una mala costumbre que hemos adquirido, en primer lugar por que nos da la sensación de que no somos productivos ya que no "vemos" líneas de código de ningún lenguaje de programación, y en menor medida porque no adoptamos la costumbre o disciplina de hacerlos. Lo anterior nos resulta caro una vez que nos enfrentamos a problemas que no habíamos contemplado con antelación.

Cuando he llegado a preguntar a programadores cómo es que ellos "hacen" su algoritmo, normalmente me indican que NO los hacen, o bien que los hacen en diagramas de flujo. Un problema con esa respuesta es que no dice cómo es que los hacen, solamente me indican que, cuando ya tienen un algoritmo (pudiese ser que solamente en su mente), lo documentan en diagramas de flujo.

Además, en efecto, los algoritmos se pueden representar (documentar) de diferentes formas, por ejemplo con pseudocódigo, con diagramas de flujo, diagramas UML, diagramas Nassi-Shneidermann. Y aún y cuando existen herramientas que nos permiten hacer diagramas de flujo, diagramas de secuencia, diagramas de clase, entre otros, invariablemente llegaremos a un punto donde tendremos que describir con detalles cómo se efectúan las cosas, es decir, llegamos a un punto donde debemos escribir un algoritmo.

En la mayor parte de los libros de programación que he leído, no indican cómo hacer algoritmos, normalmente enseñan un lenguaje y dan por hecho que los lectores deben aprender la sintaxis de los lenguajes y con ello ya saben programar.

Es por ello que aquí expongo un algoritmo para crear algoritmos, y éste está basado un los pasos indicados en el libro "Introducción a las Ciencias de la Computación: Un enfoque algorítmico" de Jean Paul Tremblay y Richard B. Bunt.

Por lo pronto enumeraré los pasos. En siguientes publicaciones ahondaré en cada uno de ellos.


Para hacer un algoritmo es necesario tener:

  1. Papel
  2. Lápiz
  3. Un problema a resolver

Los pasos a seguir para crear un algoritmo son:

  1. Responder con un SI las siguientes preguntas. ¿Entiendo el problema? ¿Sé cómo se hace? ¿Puedo hacerlo? ¿Puedo identificar un resultado correcto de uno incorrecto?
  2. Escribir a "grosso modo" una versión inicial del algoritmo.
  3. A partir del listado de pasos actual de nuestro algoritmo, identificar: Variables Constantes Tipos de datos Fórmulas Restricciones Nuevas dudas a investigar
  4. Detallar "un poco más" cada uno de los pasos de nuestro algoritmo actual.
  5. Repetir los pasos 3 y 4 hasta que esté "lo suficientemente detallado".
  6. Ejecutar a mano (en el papel) nuestro algoritmo y corregir los errores.
  7. Codificar nuestro algoritmo en el lenguaje de nuestra elección.

Como se puede observar en el listado, el codificar el algoritmo en un lenguaje de programación (cualquiera que hayamos elegido) es el último paso.