Estructuras de control; secuenciales y selectivas
Bueno, bueno: ya hemos hablado un poco de variables; qué son, y
cosas que podemos hacer con ellas. También hablamos un poco por
encima de lo que es un algoritmo, pero aún no sabemos cosas sobre
ellos. Una posible "definición rigurosa" sería la
siguiente (no hay que tomarla como un dogma de fe):
| Un algoritmo es una sucesion finita de pasos no ambiguos que se
pueden llevar a cabo en un tiempo finito. |
|---|
Sucesión finita es lo contrario de infinita: esto quiere decir
que se acaba en algún momento ;)
Pasos no ambiguos son pasos tan claros que hasta una máquina
los puede entender, de ahí la necesidad de la no
ambigüedad ;)
Lo del tiempo finito es una cuestión práctica: no creo que
tengamos tanta paciencia (ni que lleguemos vivos, sobre todo)
como para ver la salida de un programa que calcule Pi :)
No vamos a entrar en filosofías de qué puede ser considerado
como un algoritmo, qué no lo es, etc... , no porque
no sea interesante en sí, sino porque a nosotros lo que nos
preocupa en estos momentos es aprender a
resolver problemas, y a eso es a lo que vamos.
No hay que confundirse: un algoritmo no es lo mismo que un programa,
para hacer un programa necesitamos algo más:
unas estructuras de datos.
Hay distintas formas de escribir un algoritmo, bien usando un
lenguaje específico de descripción de algoritmos,
bien mediante representaciones gráficas.
Yo he elegido la primera: el pseudocódigo. Que sea un
lenguaje específico no significa que haya que aprender un
idioma nuevo, lo único que quiere decir es que hay unas
cuantas palabras que son clave, y que son las palabras que, de
acuerdo a unas reglas muy sencillitas, nos ayudan a describir
el algoritmo.
La estructura del pseudocódigo es bastante parecida a la de algunos
lenguajes de programación (por ejemplo, el Pascal), por ello me
ha parecido la más recomendable.
El pseudocódigo tiene algunas ventajas:
- Es fácil hacer cambios si nos equivocamos en la
lógica del programa
- Es independiente del lenguaje de programación que
vaya a usarse; un algoritmo que esté escrito en
pseudocódigo es fácilmente traducible a
muchos lenguajes de programación.
Y ya, sin más preámbulos, vamos a lo que nos interesa:
nosotros queremos resolver problemas con el ordenador, ¿no es
así? Pues veamos con qué herramientas nos podemos defender
para escribir nuestros propios algoritmos.
Elementos básicos para la descripción de algoritmos
El principio y el fin
Para delimitar el comienzo y el final de un algoritmo, o de un
trozo de algoritmo (por ejemplo, en los bucles, y otros, como vamos
a ver), haremos lo siguiente:
inicio
... Aqui va el algoritmo en cuestion
fin
También, en vez de inicio y fin se puede usar "empezar" y "fin",
o lo que querais, pero siempre quedando clara la intención. No hay
que ser estrictamente riguroso con la aplicación del "inicio-fin",
muchas veces, una buena indentación hace su papel.
Asignaciones
Sobre las asignaciones ya hablamos la vez pasada, al tratar el
tema de las variables, vamos a recordarlo brevemente:
Cuando hayamos declarado una variable, llegará un momento en el
que querremos que la variable tome algún valor. Por ejemplo,
tenemos una variable de tipo entero que se llama I y queremos
asignarle el valor 3, entonces, escribiremos:
I <- 3
Comentarios
Poner comentarios de lo que vamos haciendo es muy útil, sobre todo
cuando llega la hora de revisar el algoritmo, si no, más de una
vez nos encontraremos diciendo "uumm... ¿qué demonios
hacía esto?"
No cuesta nada documentar el código y nos ahorrará dolores de cabeza :)
La convención que seguiremos será poner los comentario
entre llaves. Así, {esto será un comentario}
Estructuras de control
Las estructuras de control tienen una finalidad bastante definida:
su objetivo es ir señalando el orden en que tienen que sucederse los
pasos de un algoritmo.
Veamos un ejemplo: supongamos que acabamos de mostrar un mensaje
en la pantalla que pregunte al usuario "¿desea seguir
adelante?".
Obviamente, de la respuesta del usuario va a depender la siguiente
acción del programa. Por ejemplo, si este mensaje se nos
presenta tras haber pulsado un botón de cerrar la
aplicación, si nosotros elegimos "Sí", la
aplicación se cerrará, y si elegimos "No", la
aplicación seguirá adelante. El programador tiene que
haber escrito código para las dos posibilidades, aunque cuando
el programa esté funcionando, sólo se elegirá
una.
Las estructuras de control son de tres tipos:
- Secuenciales
- Selectivas
- Repetitivas
Estructuras secuenciales
Una estructura de control secuencial, en realidad, no es más que
escribir un paso del algoritmo detrás de otro, el que primero se
haya escrito será el que primero se ejecute (al implementarlo,
por ejemplo).
Veamos un ejemplo: queremos leer el radio de un círculo, calcular
su área y mostrar por pantalla al usuario el resultado.
Declaracion de variables
REAL: radio, area
fin declaracion de variables
inicio
mostrar por pantalla 'dame el radio del circulo'
leer del teclado la variable radio
area <- 3.14159*radio
mostrar por pantalla 'el area del circulo es:'
mostrar por pantalla el contenido de la variable area
fin
Notar una cosa: cuando queremos hacer cosas relativas a entrada o
salida por algún dispositivo, como el teclado, la pantalla o la
impresora, yo pongo cosas como "mostrar por pantalla", o "leer del
teclado". Dado que cada lenguaje de programación tiene sus
funciones de entrada/salida, no uso la forma particular de ninguno,
simplemente, lo que le diríamos al ordenador en caso de que
fuera una persona ("oye, por favor, sácame esto por
impresora").
Por otro lado, cuando queramos decir que nos muestre el contenido
de una variable, yo he puesto "mostrar por pantalla el contenido
de la variable area", pero podía haber puesto igualmente
"mostrar por pantalla area", o cosas similares. Vosotros elegís
la forma que os resulte más clara o más cómoda,
lo importante es que las intenciones sean claras, o, lo que es lo mismo,
"no ambiguas" ;)
Además, si os fijais, para que quede claro que una cosa es mostrar
por pantalla una cadena, y otra cosa es mostrar por pantalla el
valor de una variable, el texto que aparece entre ' ' es una
cadena, mientras que el que no aparece entre ' ' no es una
cadena, sino que se refiere a una variable.
Ahora vamos a pasar a las estructuras selectivas y a las repetitivas.
Para ello, necesitamos primero hablar un poco de... CONDICIONES.
La palabra condición nos sugiere frases como "lo haré a
condición de que me dejes tu boli". Analicemos esta frase con
un poco de detenimiento.
Decimos "lo haré", pero, ¿"lo haré" siempre, pase
lo que pase? o, por el contrario, ¿"lo haré" si antes
hay algo que debe cumplirse? En la frase está claro que no se
ha dicho "lo haré" sin más, si no que hay como una
pequeña cláusula "SI me dejas tu boli".
Ya nos ha vuelto a aparecer el SI; esto parece querer decir que
debe ser algo importante.
Lo que significa "SI me dejas tu boli" es lo siguiente, en caso
de que la acción "dejarme tu boli" sea cierta (o verdad,
usaré ambas palabras), yo "lo haré". Pero si la
acción "dejarme tu boli" es falsa (o mentira), yo NO "lo
haré".
En esto reside el "quid" de las estructuras que vamos a ver a
continuación: se EVALUA una condición, y se
actúa en consecuencia, según que la
condición sea VERDADERA o FALSA.
Estructuras selectivas
Estas estructuras se utilizan para TOMAR DECISIONES (por eso
también se llaman estructuras de decisión o alternativas).
Lo que se hace es EVALUAR una condición, y, a continuación,
en función del resultado, se lleva a cabo una opción u
otra.
Alternativas simples
Son los conocidos "si... entonces". Se usan de la siguiente
manera (una vez más, la escritura es más o menos
personal, siempre que las intenciones queden claras para todos): yo
quiero evaluar una condición, y si se cumple (es decir, si es
cierta), entonces realizaré una serie de pasos. Esto lo
podemos escribir así:
SI se cumple la condicion, ENTONCES:
Hago el paso 1
....
Hago el paso N
fin del SI
Muy estrictamente, sería:
SI se cumple la condicion, ENTONCES:
inicio
Hago el paso 1
....
Hago el paso N
fin
fin del SI
pero con una buena sangría nos podemos evitar escribir de
más ;)
Es importante cerrar el SI, ya que, si no se cumple la
condición, el programa seguirá a continuación
de donde termina el SI.
Por ejemplo, queremos calcular la raíz cuadrada de un
número; sin embargo todos sabemos (¡supongo! ;))
que la raíz cuadrada de un número negativo NO es un
número real. Esto quiere decir que, tras leer el número
por teclado, tendremos que ver si es positivo, ya que sólo en
este caso podremos calcular su raíz cuadrada.
Veamos como queda:
Declaracion de variables
REAL: numero, raiz
fin declaracion de variables
inicio
mostrar por pantalla 'introduce un numero'
leer del teclado la variable numero
SI numero >= 0 ENTONCES:
raiz <- raiz_cuadrada(numero)
mostrar por pantalla 'la raiz cuadrada es:'
mostrar por pantalla raiz
fin del SI
fin
Como extraer una raíz cuadrada es una operación que, en
principio, no es elemental, yo he puesto
raiz_cuadrada(numero), eso significa que, en alguna
parte, tengo definida una función que me calcula la
raíz cuadrada de un número. Ya hablaremos
de funciones y subrutinas más adelante, pero hago esta
aclaración para que conste que raiz_cuadrada
no forma parte de ningún tipo de especificación
de pseudocódigo ;-)
Sin embargo, hubiera sido bonito haber podido avisar al usuario
de que no podíamos calcular la raíz cuadrada en caso de
que el número fuera negativo, pero no os preocupeis, para ello
tenemos las...
Alternativas dobles
O el famoso trío "si ... entonces ... sino"
;-D
Se usan de esta forma: queremos evaluar una condición, si es
verdad, realizaré una serie de pasos, y SI NO es verdad (es decir,
si es falsa, si es una puerca mentira cochina... ;) ), entonces
realizaré otra serie de pasos. Esto lo podemos
escribir así:
SI se cumple la condicion, ENTONCES:
Hago el paso A1
....
Hago el paso AN
y SI NO se cumple la condicion, ENTONCES:
Hago el paso B1
....
Hago el paso BM
fin del SI
Con esto, nuestro algoritmo para la raíz cuadrada
quedaría:
Declaracion de variables
REAL: numero, raiz
fin declaracion de variables
inicio
mostrar por pantalla 'introduce un numero'
leer del teclado la variable numero
SI numero >= 0 ENTONCES:
raiz <- raiz_cuadrada(numero)
mostrar por pantalla 'la raiz cuadrada es:'
mostrar por pantalla raiz
SI NO es numero >=0 ENTONCES: {es decir, si numero es negativo}
mostrar por pantalla 'lo siento, no puedo calcular
la raiz cuadrada de un numero negativo'
fin del SI
fin
Alternativas múltiples
Es muy probable que tengamos la necesidad de incluir en nuestros
programas alternativas con muchas opciones posibles. Esto lo
podríamos hacer a base de anidar
"si ... entonces ... si no", pero
si es un número elevado de alternativas, se hace demasiado
farragoso como para resultar inteligibles. Por ejemplo, si
queremos hacer un menú que dé a elegir cuatro opciones,
un posible algoritmo sería:
{Algoritmo MENU a base de 'si ... entonces ... sino'}
Declaracion de variables
ENTEROS: opcion
fin declaracion de variables
inicio
mostrar por pantalla 'menu de opciones:'
mostrar por pantalla '1. Diccionario de sinonimos'
mostrar por pantalla '2. Diccionario de antonimos'
mostrar por pantalla '3. Buscar palabra'
mostrar por pantalla '4. Salir'
leer del teclado la variable opcion
SI opcion = 1 ENTONCES
{lo que toque a esta opcion}
SI NO, ENTONCES
SI opcion = 2 ENTONCES
{lo que toque a esta opcion}
SI NO, ENTONCES
SI opcion = 3 ENTONCES
{lo que toque a esta opcion}
SI NO, ENTONCES
SI opcion = 4 ENTONCES
{lo que toque a esta opcion}
SI NO, ENTONCES
mostrar por pantalla 'opcion incorrecta'
fin del SI
fin del SI
fin del SI
fin del SI
fin
Farragoso, ¿verdad?
Para evitar esto (¿os imaginais que en vez de cuatro fueran 20 las
alternativas?), está la estructura "según sea".
La idea es esta; por ejemplo, como en el algoritmo que hemos puesto
del menú, pedimos al usuario que entre una opción, y hay
cuatro posibilidades, cuatro posibles valores para los que haremos
algo.
Entonces, SEGUN lo que valga la variable opción,
elegiremos una alternativa de entre todas las posibles.
La forma de escribir esto en pseudocódigo es:
SEGUN SEA la variable o la expresion HACER
VALOR1: {las acciones que toque}
...
VALORN: {las acciones que toque}
por defecto: {las acciones que toque}
fin SEGUN
¿Qué pinta ahí ese 'por defecto'?
No es más que una alternativa por si acaso se elige alguna
opción no contemplada entre las que se ofrece.
Como ejemplo, vamos a ver nuestro menú utilizando la alternativa
múltiple SEGUN SEA:
{Algoritmo MENU a base de 'segun sea'}
Declaracion de variables
ENTEROS: opcion
fin declaracion de variables
inicio
mostrar por pantalla 'menu de opciones'
mostrar por pantalla '1. Diccionario de sinonimos'
mostrar por pantalla '2. Diccionario de antonimos'
mostrar por pantalla '3. Buscar palabra'
mostrar por pantalla '4. Salir'
leer del teclado la variable opcion
SEGUN SEA opcion HACER:
opcion = 1 : {lo que toque a esta opcion}
opcion = 2 : {lo que toque a esta opcion}
opcion = 3 : {lo que toque a esta opcion}
opcion = 4 : {lo que toque a esta opcion}
por defecto: {mostrar un posible mensaje de error}
fin SEGUN
fin
Así queda mucho más claro, no sólo para nosotros,
si no para cualquier persona que tuviera que leerlo; además, es
una forma más sencilla de manejar una alternativa
múltiple :)
Podemos abreviar un poquito el texto; es igualmente válido poner,
dentro del SEGUN, lo siguiente:
SEGUN SEA opcion HACER:
1 : {lo que toque a esta opcion}
2 : {lo que toque a esta opcion}
3 : {lo que toque a esta opcion}
4 : {lo que toque a esta opcion}
por defecto: {mostrar un posible mensaje de error}
fin SEGUN
Me quedan las estructuras repetitivas, que las veremos en la
próxima entrega, si no esto puede ser mucho trago de golpe
O:)
En cualquier caso, ya teneis cosas para ir empezando a pensar
en la escritura de algoritmos. Yo sugiero los siguientes...
Ejercicios
Sobre estructuras secuenciales
- Escribid un algoritmo que calcule el área de un
triángulo.
- Escribid un algoritmo que calcule el área de un
rectángulo.
- Escribid un algoritmo que calcule el área de un trapecio.
- Escribid un algoritmo que calcule el precio de un artículo
tras aplicarle un 16% de IVA.
- Escribid un algoritmo que intercambie el contenido de
dos variables.
Sobre estructuras selectivas
- Escribid un algoritmo que resuelva una ecuación de segundo
grado, teniendo en cuenta todas las posibles alternativas.
- Diseñad un esquema de menú de opciones, por ejemplo,
un menú para seleccionar un libro a leer de entre siete
disponibles.
- Escribid un algoritmo que lea tres números e imprima por
pantalla el mayor de ellos.
- Escribid un algoritmo que lea tres números e imprima por
pantalla el menor de ellos.
De momento, eso es todo, cuando tengamos las estructuras
repetitivas ya podremos hacer muchas más cosas :)
Estoy *especialmente* interesada en el ejercicio 5 de las
estructuras secuenciales y en el ejercicio 4 de las selectivas,
lo digo por si no podeis hacer toda la faena... ;)
Tutoriales
