Estructuras de control condicionales
En algunas partes de un algoritmo puede ser útil detenerse a hacer una pregunta porque se llegó a una situación en la que puede haber una o más opciones disponibles para continuar. Dependiendo de la respuesta a la pregunta, que siempre deberá ser VERDADERO (TRUE) o FALSO (FALSE), el algoritmo seguirá ciertas acciones e ignorará otras. Estas preguntas y respuestas representan procesos de toma de decisión que conducen a diferentes caminos dentro del algoritmo, permitiéndonos que la solución para el problema en cuestión sea flexible y se adapte a distintas situaciones. Este tipo de estructuras de control de las acciones reciben el nombre de condicionales (o estructuras de selección) y pueden ser simples, dobles y múltiples.
Estructuras condicionales simples
Postulan una evaluación lógica y, si su resultado es TRUE, se procede a ejecutar las acciones encerradas por esta estructura. se expresan en R con la siguiente sintaxis:
if (condición) {
...código para ejecutar acciones...
}La palabra if indica el comando de evaluación lógica, condición indica la evaluación a realizar y entre llaves se detallas las instrucciones que se realizarán sólo si se cumple la condición, es decir, si la evaluación resulta en TRUE. Si la condición no se verifica, no se ejecuta ninguna acción y el programa sigue su estructura secuencial con el código que prosigue a la última llave.
Karel nos va a ayudar a ejemplificar esto. La siguiente tabla muestra las evaluaciones lógicas que la robot puede realizar acerca de su mundo. Por ejemplo, si ejecutamos la función frente_abierto(), obtendremos el valor TRUE si efectivamente no hay una pared enfrente de Karel o el valor FALSE si hay una pared.
| Función en R | Devuelve VERDADERO (TRUE) si… |
|---|---|
| frente_abierto() | …no hay una pared enfrente de Karel |
| frente_cerrado() | … hay una pared enfrente de Karel |
| izquierda_abierto() | …no hay una pared a la izquierda de Karel |
| izquierda_cerrado() | …hay una pared a la izquierda de Karel |
| derecha_abierto() | …no hay una pared a la derecha de Karel |
| derecha_cerrado() | …hay una pared a la derecha de Karel |
| hay_cosos() | …hay cosos donde se encuentra Karel |
| no_hay_cosos() | …no hay cosos donde se encuentra Karel |
| karel_tiene_cosos() | …Karel tiene cosos en su mochila |
| karel_no_tiene_cosos() | …Karel no tiene cosos en su mochila |
| mira_al_este() | …Karel está mirando al este |
| mira_al_norte() | …Karel está mirando al norte |
| mira_al_oeste() | …Karel está mirando al oeste |
| mira_al_sur() | …Karel está mirando al sur |
Podemos usar una estructura condicional para modificar la función llenar_agujero() que creamos anteriormente para que Karel coloque un coso sólo si no había ya uno presente en el agujero:
# ------------ Definición de funciones auxiliares-----------
llenar_agujero <- function() {
girar_derecha()
avanzar()
if (no_hay_cosos()) {
poner_coso()
}
darse_vuelta()
avanzar()
girar_derecha()
}
# ------------------- Programa principal -------------------
generar_mundo("mundo002")
avanzar()
llenar_agujero()
ejecutar_acciones()Notar que si bien el uso de sangrías en el código es opcional, decidimos emplearlo para facilitar su lectura. Mantener la prolijidad en nuestros programas es esencial.
Estructuras condicionales dobles
Este tipo de estructura añade una acción a ejecutarse en el caso de que la condición evaluada no se verifique (es decir, devuelve el valor FALSE). La sintaxis es:
if (condición) {
...código para ejecutar acciones...
} else {
...código para ejecutar acciones...
}Dentro del primer bloque de llaves se escriben las acciones que se realizan si se cumple la condición, mientras que en el segundo, luego de la expresión else, se incluyen las que se realizan si no se verifica la misma.
Imaginemos que queremos crear un algoritmo para revertir el estado de una celda, es decir, que Karel ponga un coso si no hay o lo quite si es que hay:
Para esto podemos usar una estructura condicional doble:
generar_mundo("mundo001")
if (hay_cosos()) {
juntar_coso()
} else {
poner_coso()
}
avanzar()
if (hay_cosos()) {
juntar_coso()
} else {
poner_coso()
}
avanzar()
if (hay_cosos()) {
juntar_coso()
} else {
poner_coso()
}
ejecutar_acciones()
Dado que repetimos 3 veces, exactamente de la misma forma, el proceso de controlar si hay o no un coso para decidir quitarlo o poner uno, otra vez podemos recurrir al principio de la descomposición algorítmica y definir una función que se encargue de ellos, se forma que la acción de invertir el estado de una celda se haga de manera más sencilla. Nuestro archivo de código quedaría así:
# ------------ Definición de funciones auxiliares-----------
invertir <- function() {
if (hay_cosos()) {
juntar_coso()
} else {
poner_coso()
}
}
# ------------------- Programa principal -------------------
generar_mundo("mundo001")
invertir()
avanzar()
invertir()
avanzar()
invertir()
ejecutar_acciones()Estructuras condicionales múltiples o anidadas
Permiten combinar varias estructuras condicionales para establecer controles más complejos sobre el flujo de las acciones, representando una toma de decisión múltiple. Podemos ejemplificar la sintaxis de la siguiente forma:
if (condición 1) {
...Primer conjunto de acciones...
} else if (condición 2) {
...Segundo conjunto de acciones...
} else {
...Tercer conjunto de acciones...
}En la estructura anterior, hay una primera evaluación lógica en la cual si el resultado es VERDADERO, se ejecuta el primer conjunto de acciones y nada más. En cambio, si su resultado es FALSO, se procede a realizar una segunda evaluación lógica, que da lugar a la ejecución del segundo o del tercer bloque de acciones, dependiendo de que su resultado sea VERDADERO o FALSO, respectivamente.
