5.

Control del flujo de programas (I): Condiciones

No siempre la solución de un problema está dada por una secuencia sencilla de pasos que no tiene en
cuenta las condiciones de las variables involucradas. La mayoría de las veces debemos ser muy específicos al
verificar condiciones para tomar decisiones adecuadas.

5.1 Definición de condiciones

Para definir condiciones, lo primero que requerimos es construir una expresión booleana que defina lo que
queremos preguntar en la condición. Posteriormente escribiremos la condición en pseudocódigo1. Veamos un
ejemplo:
Un almacén de útiles escolares ofrece descuentos de acuerdo con el número de libros, lápices y cuadernos
que un cliente compre, de la siguiente manera:

• Si un cliente lleva más de 3 libros o más de 6 cuadernos, recibe un descuento del 25% sobre el total de
la cuenta.
• Si un cliente lleva uno o dos libros, tres cuadernos y por lo menos 4 lápices, recibe el 15% de
descuento.

Se requiere calcular el total a pagar después de los descuentos efectuados (Tenga en cuenta que los dos
descuentos no son acumulables).

Lo primero que debemos hacer es modelar el problema:

Entradas: Número de libros (libros), número de cuadernos (cuadernos), número de lápices (lápices) y total
antes de descuentos (total).
Salidas: Total a pagar después de descuentos (totalConDescuentos).

Posteriormente establecemos pre y poscondiciones a partir del proceso de especificación:

Precondiciones: todas las cantidades de artículos y el valor a pagar deben ser valores positivos.
Poscondiciones: el total a pagar debe ser positivo y menor o igual que el total antes de descuentos.

5.2 Representación de condiciones en pseudocódigo

Teniendo clara esta información, hablemos de la solución del problema:
Para definir cuál sería el valor total a pagar por la compra de los útiles escolares, debemos tener en cuenta
que si se llevan más de tres libros o más de seis cuadernos, el cliente recibirá un
descuento del 25%...































































1

Para
la
sintaxis
de
condiciones
en
Java,
consulta
el
documento
“Elementos
formales
del
lenguaje
Java
(II)”


Adrian
Nicolás
Malaver

Barrera
Sin darnos cuenta, hemos solucionado el problema. Hemos definido una decisión que se debe tomar bajo
ciertas condiciones que pueden ocurrir de acuerdo con el valor de las variables implicadas. Ahora solo falta
codificar la solución que se ha identificado para formalizar el algoritmo. Para ello usaremos la siguiente
notación:

Tabla 1. Notación de condiciones en pseudocódigo

si (<Condición>) entonces
instrucción 1
instrucción 2
Condición es una expresión booleana que tiene en
.
cuenta las variables que se requieren para tomar la
.
decisión que nos interesa.
.
instrucción n
fin_si

Escribamos el bloque condicional que define la solución al problema en cada caso:

Primera condición
si (libros > 3 O cuadernos > 6) entonces
totalConDescuento ← total * 0.75
fin_si

Segunda condición
si ((libros = 1 O libros = 2) Y cuadernos = 3 Y lapices >= 4 ) entonces
totalConDescuento ← total * 0.85
fin_si

Note que el flujo del algoritmo se altera, ejecutando las líneas en verde, solo si se cumple la condición
definida.
Ahora, el algoritmo completo sería:
Algoritmo Descuentos
Entradas
libros, cuadernos, lapices: Entero
total: Real
Pre: {libros>=0 Y cuadernos>=0 Y lapices>=0 Y total>= 0}
Inicio
totalConDescuento ← total

si(libros>3 O cuadernos>6) entonces

totalConDescuento ← total*0.75
fin_si

si((libros=1 O libros=2) Y cuadernos=3 Y lapices>=4) entonces

totalConDescuento ← total*0.85

Adrian
Nicolás
Malaver

Barrera
 fin_si
Fin
Salidas
totalConDescuento: Real
Pos: {totalConDescuento >= 0 Y totalConDescuento <= total}

Inicialmente se define que totalConDescuento será igual al total del que partimos; esto para definir que si no se
cumple ninguna de las dos condiciones, el total será el mismo. Posteriormente se definen las condiciones
bajo las cuales el total se modificaría.
Hasta aquí todo está bien, pero consideremos una ligera modificación en la segunda condición para definir
que para obtener el descuento del 15% un cliente debe llevar uno o dos libros, más de tres cuadernos y por
lo menos 4 lápices. El algoritmo sería:

Inicio
totalConDescuento ← total

si(libros>3 O cuadernos>6) entonces

totalConDescuento ← total*0.75
fin_si

si((libros=1 O libros=2) Y cuadernos>3 Y lapices>=4) entonces totalConDescuento ← total*0.85

fin_si
Fin

¿Este algoritmo funcionaría bien? Aparentemente sí, pero consideremos las siguientes entradas: libros = 2,
cuadernos = 7, lápices = 4.
Con estos valores de entrada, la ejecución de la primera versión del algoritmo no tendría problemas; sin
embargo, ¿Qué pasaría en el segundo caso? Las dos condiciones se cumplirían y se aplicaría el descuento
dos veces:

Primera condición:
libros>3 O cuadernos>6
2 >3 O 7 >6
F O V
V

Segunda condición:
(libros=1 O libros=2) Y cuadernos>3 Y lapices >=4
(2 =1 O 2 =2) Y 7 >3 Y 4 >=4
( F O V )Y V Y V
V Y V
V

Adrian
Nicolás
Malaver

Barrera
En el primer caso todo funcionaba porque no existían valores para los cuales se cumplieran las dos
condiciones, en cambio, para el segundo caso, ya sabemos que el algoritmo fallaría para ciertos valores de
las variables de entrada. Entonces ¿Cómo lo solucionamos?
La idea es que las condiciones especificadas permitan realizar instrucciones si se cumple lo que dicen, pero
también permitan especificar qué debería suceder si no se cumple. Lo que haremos en casos como estos es
usar una definición más amplia de las condiciones de la siguiente manera:

Algoritmo Descuentos
Entradas
libros, cuadernos, lapices: Entero
total: Real
Pre: {libros>=0 Y cuadernos>=0 Y lapices>=0 Y total>= 0}
Inicio
totalConDescuento ← total

si(libros>3 O cuadernos>6) entonces

totalConDescuento ← total*0.75
sino
si((libros=1 O libros=2) Y cuadernos>3 Y lapices>=4) entonces
totalConDescuento ← total*0.85
fin_si
fin_si
Fin
Salidas
totalConDescuento: Real
Pos: {totalConDescuento >= 0 Y totalConDescuento <= total}

De esta forma sabremos que nunca se ejecutarán las dos líneas de las que hablamos antes. En general,
requerimos hacer esto cuando los casos o condiciones que se tienen en cuenta son excluyentes entre sí, esto
es, la intersección de los conjuntos que cumplen cada condición, es vacía.

5.3 ¿Qué son las condiciones en Java?

Una condición en un lenguaje de programación es un recurso que podemos usar para controlar el flujo de un
programa. Hasta ahora este flujo había sido totalmente lineal; cada instrucción se ejecutaba detrás de otra
sin tener en cuenta nada más. A partir de la definición de condiciones es posible realizar la ejecución de una
serie de instrucciones solo si se cumplen ciertas cosas. Por ejemplo, si se requiere hacer una división entre
dos variables enteras a y b, debería hacerse solo si el denominador es distinto de cero, dado que en otro
caso, incurriríamos en un error.
Una condición en el lenguaje de programación Java se representa como una expresión booleana que
involucra las variables o constantes requeridas para verificar el estado del sistema en un momento
determinado, con el objetivo de tomar una decisión.

Adrian
Nicolás
Malaver

Barrera
5.4 Selección múltiple
Observemos la siguiente situación: Dados los valores de dos variables a y b, se requiere hacer una operación
binaria (+,-.*,/) de acuerdo con un valor de selección (seleccion) que será 1,2,3 o 4. Si la variable de
selección no corresponde a estos valores, el resultado será 0. Es posible hacerlo con condiciones de la
siguiente forma:

si(selección = 1) entonces
resultado ← a + b
sino
si(seleccion = 2) entonces
resultado ← a - b
sino
si(seleccion = 3) entonces
resultado ← a * b
sino
si(seleccion = 4) entonces
resultado ← a / b
sino
resultado ← 0
fin_si
fin_si
fin_si
fin_si

Sin embargo, para un número mayor de casos, el código se torna difícil de entender. Para casos como estos
se ha definido una estructura que complementa la funcionalidad de los bloques condicionales a través del
uso de la selección múltiple. Para usar esta estructura, debemos tener en cuenta que requerimos de la
definición de una expresión numérica entera que representa el valor que se quiere evaluar, y un conjunto de
casos, definidos por constantes numéricas enteras, que representan lo que se debe hacer si se da uno de
dichos casos. Veamos cómo funciona:

seleccionar (<condición>)
caso <valor constante 1>
instrucciones
caso <valor constante 1>
instrucciones
caso <valor constante 1>
instrucciones
en otro caso
instrucciones
fin_seleccionar

De acuerdo con esta estructura, el pseudocódigo presentado en el ejemplo puede convertirse en:

Adrian
Nicolás
Malaver

Barrera
seleccionar (seleccion)

caso 1
resultado ← a + b

caso 2
resultado ← a – b

caso 3
resultado ← a * b

caso 4
resultado ← a / b

en otro caso
resultado ← a + b

fin_seleccionar
Esta estructura es muy útil, ya que nos permite disminuir el volumen del pseudocódigo de nuestros
algoritmos y entender mejor la lógica de las soluciones propuestas a problemas y ejercicios. Hay que tener
en cuenta algunas cosas:

• La expresión que permite hacer la selección, siempre debe ser de tipo entero
• Cada caso se representa con valores constantes
• Debemos ser muy cuidadosos en la escritura de cada caso, ya que, como no se usan palabras como
inicio y fin, tenemos en cuenta las instrucciones que serán ejecutadas, de acuerdo con el nivel de
tabulación.

En resumen
Es posible definir condiciones bajo las cuales se ejecuta o no una serie de instrucciones de un algoritmo a
través de la definición de expresiones booleanas que tienen en cuenta el valor de las variables involucradas
en el algoritmo.
Las condiciones son la primera estructura de control que nos permite alterar el flujo de los algoritmos que
definimos.
Además, es posible usar la estructura de selección múltiple cuando queramos definir instrucciones que
suceden de acuerdo con el resultado entero de una variable o una expresión.

Para tener en cuenta:

• Es muy importante escribir el código de los algoritmos de forma ordenada, en este caso tabulando las
líneas de pseudocódigo para que sea más fácil identificar qué instrucciones se ejecutarán si se cumple o
no se cumple una condición.

• Siempre que se defina el inicio de una estructura usando “inicio_si” o “sino” no debemos olvidar cerrar
el bloque usando “fin_si”.

Adrian
Nicolás
Malaver

Barrera