Estructuras de control del código

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.

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.

Estructuras de control iterativas con un número fijo de iteraciones

Se aplican cuando se conoce de antemano el número exacto de veces que se debe repetir una secuencia de acciones. Por ejemplo, consideremos el siguiente problema donde hay agujeros distribuidos equiespaciadamente en las avenidas pares.

Tenemos que escribir un programa para que Karel llene los 5 agujeros. Podríamos planear algo como:

# ------------------- Programa principal -------------------

generar_mundo("mundo003")
avanzar()
llenar_agujero()
avanzar()

avanzar()
llenar_agujero()
avanzar()

avanzar()
llenar_agujero()
avanzar()

avanzar()
llenar_agujero()
avanzar()

avanzar()
llenar_agujero()
avanzar()
ejecutar_acciones()

Es evidente que no tiene sentido escribir exactamente lo mismo 5 veces. Por eso vamos a hacer uso de una estructura iterativa:

generar_mundo("mundo003")
for (i in 1:5) {
  avanzar()
  llenar_agujero()
  avanzar()
}
ejecutar_acciones()

La letra i recibe el nombre de variable de iteración. Podríamos haber elegido otra letra u otra palabra en su lugar, pero emplear i es bastante común. En este ejemplo, su única función es guiar la serie de pasos. El bloque de instrucciones se repite tantas veces como i tarde en llegar a 5 partiendo desde 1. De manera general, la sintaxis para este tipo de estructuras es:

for (<variable> in <valor1>:<valor2>) {
    ...Acción/es...
}

Estructuras de control iterativas con un número indeterminado de iteraciones

En otras circunstancias se puede necesitar repetir un bloque de acciones sin conocer con exactitud cuántas veces, si no que esto depende de algún otro aspecto del ALGORITMO. Las iteraciones pueden continuar mientras que se verifique alguna condición. En este tipo de estructuras, el conjunto de instrucciones se repite mientras que se siga evaluando como VERDADERO una condición declarada al inicio del bloque. Cuando la condición ya no se cumple, el proceso deja de ejecutarse. La sintaxis es:

while (<condición>) {
    ...Acción/es a repetir...
}

Observaciones:

• La evaluación de la condición se lleva a cabo antes de cada iteración, incluyendo la primera. Si la condición es FALSO inicialmente, entonces las acciones en el cuerpo de la estructura no se ejecutan nunca.
• La evaluación de la condición sólo se lleva a cabo al inicio de cada iteración. Si la condición se vuelve FALSO en algún punto durante la ejecución de un bloque, el programa no lo nota hasta que se termine de ejecutar el bloque y la condición sea evaluada antes de comenzar la próxima iteración.

Por ejemplo, sería interesante escribir un programa para llenar agujeros como el anterior, pero que sirva de manera general para otras situaciones donde puede haber cualquier cantidad de agujeros en la calle, como estas:

En vez de usar un for en el cual hay que especificar la cantidad de veces que el proceso debe repetirse, podemos usar un while para que Karel siga rellenando agujeros mientras que no haya una pared enfrente suyo, lo cual indicaría que llegó al final y debe detenerse.

# ------------------- Programa principal -------------------
generar_mundo("mundo003")
while (frente_abierto()) {
  avanzar()
  llenar_agujero()
  avanzar()
}
ejecutar_acciones()

Hay que tener mucho cuidado a la hora de escribir este tipo de estructura, para asegurarse de no producir un loop infinito, es decir, un proceso iterativo que nunca finaliza. Esto ocurriría, por ejemplo, si estando en el mundo anterior, le pedimos a Karel que gire mientras que no haya cosas donde está parada:

# No correr esto! (o sí, para ver cómo no anda!)
generar_mundo("mundo003")
while (no_hay_cosos()) {
    girar_izquierda()
}
ejecutar_acciones()

Algunos ejemplos presentados en este tutorial fueron adaptados de Karel the robot learns Java (Eric Roberts, 2005).