PCI – PCIA - PCT

Departamento de Ingeniería Eléctrica y de Computadoras

Materiales Didácticos para Educación a
Distancia

Estructuras de Control – Cheat Sheet

Noelia

CONDICIONAL IF WHILE
WHILE

La estructura de control se ejecuta solo La estructura de repetición se ejecuta

Si una condición es Verdadera, mientras la condición sea Verdadera
sino realiza otra acción. Si No
while expresión lógica do
begin Si
If expresión lógica then Si
Si
sentencia 1;
sentencia A
sentencia 2;
else
…….. No
sentencia B;
end;

if edad < 15 then s:=0;

Se pueden tener estado=’Niño’
𝑖=20 i:=1; Inicializació antes del bucle
varios else, if…Sólo se else
while (i<= 20) do
ejecuta el primero bloque
que sea verdadero
if edad >65 then
estado:= ‘Jubilado’ 𝑖2 begin
else s= s+ i*i;
𝑖=1 i:=i+1;
estado:=’Activo’;
end;

REPEAT FOR
•La instrucción o secuencia de instrucciones es el bloque iterativo y se La estructura de repetición se ejecuta
ejecuta por lo menos una vez. para cada valor inicial hasta un determinado número de veces
•Cuando la expresión lógica computa verdadero se produce la condición
de corte. for var:=inicial to valor_final do próximo
•El bloque iterativo debe modificar al menos una de las variables begin
involucradas en la expresión lógica para garantizar que la condición de sentencia1;
corte se produzca.
sentencia2;
•Si la condición de corte no se verifica nunca, se produce un bucle
infinito.
end;

repeat num:=5; Fin

fact:=1;
sentencia o secuencia de sentencias;
until expresión lógica
for i:=num downto 1 do
fact:=fact*i;
5!
La instrucción de un FOR también puede ser anidada
Un número entero que sea DIGITO

repeat suma:=0; N=3; M=5;

x:=StrToInt(InputBox('Digitos','valor','0')); for i:=1 to N do

begin
until (x>=0) and (x<10) for j:=1 to M do
suma:=suma + j + i;
end

1
 PCI – PCIA - PCT
Departamento de Ingeniería Eléctrica y de Computadoras
Materiales Didácticos para Educación a
Distancia

Ejemplos de resolución

Tema: Estructuras repet itivas

Problema:
Diagramar la ventana de aplicación e implementar un programa que permita calcular

y mostrar en pantalla:

a) Los 10 primeros múltiplos de un número entero ingresado por el usuario

b) Los cuadrados de los 5 valores consecutivos a un número entero ingresado por el usuario.

Resolución:
Inicialmente vamos a determinar cuál es la información que debemos brindarle al usuario

luego de que ejecute el programa, así como la información que necesitamos para poder brindarle

esa respuesta. En este ejemplo, el usuario nos indicará el valor de un número entero, que

podemos utilizar para ambos incisos solicitados. Por lo tanto, nuestro programa deberá tener 1

dato de entrada.

Cuando analizamos la respuesta a generar, vemos que se deben mostrar 10 valores para

cumplir lo solicitado en el inciso a (es decir, los 10 múltiplos) y otros 5 valores para cumplir lo

solicitado en el inciso b (es decir, los 5 cuadrados). Si pensáramos en utilizar una variable para

almacenar cada uno de estos resultados, nuestro programa necesitaría de 15 variables. Si bien

esto es factible, no parece una solución adecuada y que se pueda adaptar a alguna modificación

simple del enunciado. Por ejemplo, en el inciso a) nos podrían pedir los 20 o 100 primeros

múltiplos del valor ingresado, y nuestra cantidad de variables aumentaría notablemente. Además

de tener muchas variables, tendríamos un código muy extenso.

1
 PCI – PCIA - PCT
Departamento de Ingeniería Eléctrica y de Computadoras
Materiales Didácticos para Educación a
Distancia

En estas situaciones, el uso de estructuras repetitivas puede simplificarnos la solución y

particularmente en este ejemplo será útil para reducir la cantidad de variables necesarias. No

obstante, el programa debe de todos modos generar 10 múltiplos y 5 cuadrados. Entonces, en

lugar de enfocarnos en la cantidad de resultados de cada uno, podemos distinguir los resultados

por tipo (múltiplo o cuadrado) y considerar así que nuestro programa tiene 2 tipos de dato de

salida. Esto implica la reutilización de variables, lo cual es habitual cuando empleamos

estructuras repetitivas.

De acuerdo al análisis anterior, podemos realizar un esquema de la aplicación de la siguiente

manera:

Datos de Datos de
entrada salida
DS

X Algoritmo Múltiplo
(numero Cuadrado
entero)

Con este diagrama, un cambio del enunciado que nos pida mostrar más o menos múltiplos o

cuadrados, no afectaría la estructura del programa.

Para el diseño de la ventana, debemos considerar los elementos necesarios para brindarle al

usuario la posibilidad de:

1) Ingresar un número: usaremos un componente TEdit, acompañado de un componente

TLabel para la leyenda correspondiente.

2) Obtener los múltiplos o los cuadrados: usaremos dos componentes TButton.

3) Visualizar los resultados: usaremos un componente TMemo.

Un detalle importante sobre la visualización: elegimos un TMemo porque permite mostrar la

cantidad de líneas necesarias (es decir, podemos mostrar un resultado por línea)

2
 PCI – PCIA - PCT
Departamento de Ingeniería Eléctrica y de Computadoras
Materiales Didácticos para Educación a
Distancia

independientemente de la cantidad de múltiplos o cuadrados que necesitemos. Otras dos

opciones serían:

a) Utilizar ShowMessage: pero al mostrar el primer resultado, debemos esperar a que el

usuario presione ‘Ok’ para poder continuar con el siguiente.

b) Utilizar TEdit: si bien es factible, el programa se ejecutará tan rápido que el usuario sólo

podrá visualizar el último valor que se muestre.

Para cualquiera de los casos anteriores, una solución posible es emplear una variable de tipo

String para concatenar todos los resultados (separados por comas, guiones u otro símbolo) y

visualizar sólo una vez luego de calcular todos. Ante estas alterativas, el componente TMemo

resulta más sencillo de utilizar y por eso lo elegimos.

La ventana de aplicación tendrá el siguiente aspecto:

Teniendo en claro lo anterior, vamos a pasar a la implementación del código.

¿Cómo obtenemos el valor ingresado por el usuario?

Suponiendo que el componente que colocamos para permitir esta acción lo llamamos Edit1 (el

nombre por defecto que le asigna Delphi), debemos obtener el contenido .text y convertir el tipo

de dato a entero. Lo podemos lograr de esta manera:

var x: integer;
begin
x:= StrToInt([Link]);
end;

3
 PCI – PCIA - PCT
Departamento de Ingeniería Eléctrica y de Computadoras
Materiales Didácticos para Educación a
Distancia

El código anterior no será de utilidad hasta no incluirlo dentro del bloque correspondiente a cada

botón. Nos concentramos primero en el inciso a) para obtener los 10 primeros múltiplos. Estos

múltiplos se obtienen realizando el producto entre el valor ingresado por el usuario (que

almacenamos en la variable x).

Si realizamos estos cálculos sucesivamente y cada vez lo almacenamos en la variable multiplo,

tendríamos lo siguiente:

Primera vez: multiplo := x * 1

Segunda vez: multiplo := x * 2
Tercera vez: multiplo := x * 3
…
Décima vez: multiplo := x * 10

La clave para determinar la forma en que emplearemos una estructura repetitiva consiste en

observar que parte de la expresión se mantiene y que parte cambia en cada vez que repetimos.

Con la lista anterior, vemos que la asignación siempre se realiza a la misma variable multiplo,

mientras que el cálculo siempre contiene a la variable x. Lo único que cambia es el factor por el

cual se multiplica. ¿Cómo cambia? Comienza en 1 y aumenta consecutivamente en 1 hasta

llegar a 10. Esta frase determina directamente la estructura repetitiva. Si en lugar de colocar

el factor directamente, agregamos una variable auxiliar llamada factor, la lista de pasos anterior

se puede reescribir de esta manera:

Primera vez: factor:= 1; multiplo := x * factor;

Segunda vez: factor:= 2; multiplo := x * factor;
Tercera vez: factor:= 3; multiplo := x * factor;
…
Décima vez: factor:= 10; multiplo := x * factor;

Observando las líneas de esta manera, logramos que la operación quede expresada de la misma

manera en todos los casos, por medio de la sentencia:

multiplo:= x * factor;

Esto funcionará si el valor almacenado en factor es distinto en cada paso, y particularmente

dijimos que comienza en 1 y aumenta consecutivamente en 1 hasta llegar a 10. Esta

4
 PCI – PCIA - PCT
Departamento de Ingeniería Eléctrica y de Computadoras
Materiales Didácticos para Educación a
Distancia

variación puede ser implementada por medio de cualquier estructura (que también llamamos

ciclo) de control repetitiva: FOR, WHILE o REPEAT.

En especial, la estructura del ciclo FOR es muy conveniente para nuestro caso. Recordemos su

sintaxis para el caso de variables que se incrementan:

FOR variable_control:= valor_inicial TO valor_final DO

begin
// Sentencias que se repetirán en cada iteración
end;

Decimos que es la más conveniente por el hecho de que si la variable de control es de tipo

entero, siempre se incrementa consecutivamente en una unidad, tal como queremos en

este ejemplo. Además, conocemos ya nuestro valor_inicial que deberá ser 1, y nuestro

valor_final que deberá ser 10. La variable_control que hemos elegido antes es factor.

Algunas observaciones:

a) El ciclo podrá ejecutarse sólo si valor_inicial es menor o igual que valor_final.

b) Se incrementa porque usamos la palabra reservada TO, si quisiéramos que se

decremente, deberíamos utilizar DOWNTO.

c) La variable de control debe ser únicamente un tipo ordinal, ya que debe estar

unívocamente definido el siguiente valor en orden consecutivo. Esto implica utilizar, por

ejemplo, variables de tipo integer o tipo char (el orden entre dos caracteres lo define su

posición en el alfabeto) y excluye el uso de variables de tipo real.

d) Conociendo la sintaxis, para cualquier aplicación en la que necesitemos este ciclo, será

suficiente con determinar que nombre de variable de control queremos utilizar, cual es

el primer valor que le debemos asignar y cual es el último valor que le debemos asignar.

e) Es obligatorio el uso de BEGIN/END para delimitar el bloque de instrucciones que deben

repetirse.

En base a este análisis, el código completo que escribiremos dentro del bloque correspondiente

al botón 1 será:

5
 PCI – PCIA - PCT
Departamento de Ingeniería Eléctrica y de Computadoras
Materiales Didácticos para Educación a
Distancia

// Código del botón 1: resuelve inciso a) calcular y mostrar los 10 primeros múltiplos
var
x, multiplo, factor: integer;
begin
// obtenemos el valor ingresado por el usuario
x:= StrToInt([Link]);
// implementamos el ciclo
for factor:=1 to 10 do
begin
// calculamos el múltiplo correspondiente
multiplo:= x * factor;
// y lo mostramos en el componente que llamamos Memo1
[Link](‘Múltiplo calculado:’ + IntToStr(multiplo));
end;
end;

Con la sentencia que utiliza el Memo1, estamos agregando una línea por cada valor calculado y

armamos una pequeña frase. Por ejemplo, si el usuario ingresa el valor 2, al presionar el botón

1 se mostrará en el Memo1 lo siguiente:

Múltiplo calculado: 2
Múltiplo calculado: 4
Múltiplo calculado: 6
Múltiplo calculado: 8
Múltiplo calculado: 10
Múltiplo calculado: 12
Múltiplo calculado: 14
Múltiplo calculado: 16
Múltiplo calculado: 18
Múltiplo calculado: 20

Intentemos ahora realizar un análisis similar para el inciso b). Nos pide mostrar los cuadrados

de los siguientes 5 números consecutivos al ingresado por el usuario. Si almacenamos

nuevamente este valor en la variable x, el número consecutivo será x+1, luego x+2 y así hasta

llegar a x+5. Es decir, el valor inicial es x+1, mientas que el valor final es x+5. Digamos que

estos valores los almacenamos consecutivamente en la variable numero. La sentencia para

obtener los resultados y almacenarlos en la variable cuadrado será:

cuadrado:= numero * numero;

Y juntando todo, podemos escribir el siguiente código en el bloque correspondiente al boton2:

6
 PCI – PCIA - PCT
Departamento de Ingeniería Eléctrica y de Computadoras
Materiales Didácticos para Educación a
Distancia

// Código del botón 2: resuelve inciso b) calcular y mostrar los cuadrados de los 5 números
// consecutivos al ingresado por el usuario

var
x, cuadrado, numero: integer;
begin
// obtenemos el valor ingresado por el usuario
x:= StrToInt([Link]);
// implementamos el ciclo
for numero:= x+1 to x+5 do
begin
// calculamos el cuadrado correspondiente
cuadrado:= numero * numero;
// y lo mostramos en el componente que llamamos Memo1
[Link](‘Cuadrado calculado:’ + IntToStr(cuadrado));
end;
end;

Con la sentencia que utiliza el Memo1, estamos agregando una línea por cada valor calculado y

armamos una pequeña frase. Por ejemplo, si el usuario ingresa el valor 3, al presionar el botón

1 se mostrará en el Memo1 lo siguiente:

Cuadrado calculado: 16
Cuadrado calculado: 25
Cuadrado calculado: 36
Cuadrado calculado: 49
Cuadrado calculado: 64

Vemos que el primer valor mostrado debe corresponder al cuadrado del número 4, ya que es el

primer entero consecutivo de 3. Llegamos a visualizar entonces hasta el cuadrado del número

8.

7
 PCI – PCIA - PCT
Departamento de Ingeniería Eléctrica y de Computadoras
Materiales Didácticos para Educación a
Distancia

Lo anterior resuelve el problema planteado utilizando la estructura de control FOR, porque

consideramos que es la opción más apropiada en este caso, pero no significa que sea la única

alternativa.

¿Qué podemos hacer si se nos exige utilizar la estructura WHILE?

En primer lugar, veamos la sintaxis equivalente a la mostrada para el ciclo FOR:

variable_control:= valor_inicial;
WHILE (variable_control <= valor_final) DO
begin
// Sentencias que se repetirán en cada iteración

// incremento de la variable
variable_control:= variable_control + 1;
end;

Algunas observaciones:

a) El ciclo podrá ejecutarse sólo si valor_inicial es menor o igual que valor_final.

b) La variable_control ya no se actualiza automáticamente, debemos incluir la sentencia

correspondiente antes de finalizar el bloque. Actualizar la variable puede significar un

incremento, decremento o cualquier otro tipo de operación.

c) El bloque de instrucciones se repetirá mientras que se cumpla la condición indicada,

la que escribimos a continuación de la palabra reservada WHILE. Esto lo hace aplicable

en situaciones en las que no conocemos de antemano cuantas veces debe repetirse el

bloque de instrucciones. Además, la condición puede ser mucho más compleja e incluso

operar sobre todo tipo de variables.

d) Si la condición se cumple la primera vez y el código no incluye una actualización de la

variable de control, se producirá lo que llamamos un bucle infinito: el bloque se repite

indefinidamente y el programa “se tilda”, sin posibilidad de solucionar el error.

e) Conociendo la sintaxis, para cualquier aplicación en la que necesitemos este ciclo, será

suficiente con determinar que nombre de variable de control que queremos utilizar, cual

es el primer valor que le debemos asignar, cual es el último valor que le debemos asignar

y cual es el incremento del valor en cada iteración. En ocasiones donde la condición no

8
 PCI – PCIA - PCT
Departamento de Ingeniería Eléctrica y de Computadoras
Materiales Didácticos para Educación a
Distancia

es un valor determinado, el último valor puede no ser necesario. Lo mismo ocurre con el

incremento si la variable de control no es de tipo ordinal.

f) Es obligatorio el uso de BEGIN/END para delimitar el bloque de instrucciones que deben

repetirse.

En base a este análisis, el código completo que escribiremos dentro del bloque correspondiente

al botón 1 será:

// Código del botón 1: resuelve inciso a) calcular y mostrar los 10 primeros múltiplos
var
x, multiplo, factor: integer;
begin
// obtenemos el valor ingresado por el usuario
x:= StrToInt([Link]);
// asignamos a la variable factor el primer valor que queremos
factor:= 1;
// implementamos el ciclo
while (factor<= 10) do
begin
// calculamos el múltiplo correspondiente
multiplo:= x * factor;
// y lo mostramos en el componente que llamamos Memo1
[Link](‘Múltiplo calculado:’ + IntToStr(multiplo));
// incrementamos la variable factor para la siguiente iteración (actualización)
factor:= factor + 1;
end;
end;

¿Qué podemos hacer si se nos exige utilizar la estructura REPEAT?

En primer lugar, veamos la sintaxis equivalente a la mostrada para el ciclo FOR:

variable_control:= valor_inicial;
REPEAT
begin
// Sentencias que se repetirán en cada iteración

// incremento de la variable
variable_control:= variable_control + 1;
UNTIL (variable_control > valor_final)

9
 PCI – PCIA - PCT
Departamento de Ingeniería Eléctrica y de Computadoras
Materiales Didácticos para Educación a
Distancia

Algunas observaciones:

a) El ciclo se ejecutará al menos una vez, independientemente si el valor_inicial es menor,

igual o mayor que valor_final.

b) La variable_control ya no se actualiza automáticamente, debemos incluir la sentencia

correspondiente antes de finalizar el bloque. Actualizar la variable puede significar un

incremento, decremento o cualquier otro tipo de operación.

c) El bloque de instrucciones se repetirá hasta que se cumpla la condición indicada, la

que escribimos a continuación de la palabra reservada UNTIL. Esto lo hace aplicable en

situaciones en las que no conocemos de antemano cuantas veces debe repetirse el bloque

de instrucciones. Además, la condición puede ser mucho más compleja e incluso operar

sobre todo tipo de variables. Notar que para el equivalente al ciclo WHILE, la condición

correspondiente es la relación de orden opuesta: cambiamos “<=” por “>”.

d) Si el código no incluye una actualización de la variable de control, se producirá lo que

llamamos un bucle infinito: el bloque se repite indefinidamente y el programa “se tilda”,

sin posibilidad de solucionar el error.

e) Conociendo la sintaxis, para cualquier aplicación en la que necesitemos este ciclo, será

suficiente con determinar que nombre de variable queremos utilizar, cual es el primer

valor que le debemos asignar, cual es el último valor que le debemos asignar y cual es el

incremento del valor en cada iteración. En ocasiones donde la condición no es un valor

determinado, el último valor puede no ser necesario. Lo mismo ocurre con el incremento

si la variable de control no es de tipo ordinal.

f) El bloque de instrucciones que deben repetirse queda delimitado por las palabras

reservadas REPEAT y UNTIL, por lo que no es obligatorio el uso de BEGIN/END.

En base a este análisis, el código completo que escribiremos dentro del bloque correspondiente

al botón 1 será:

10
 PCI – PCIA - PCT
Departamento de Ingeniería Eléctrica y de Computadoras
Materiales Didácticos para Educación a
Distancia

// Código del botón 1: resuelve inciso a) calcular y mostrar los 10 primeros múltiplos
var
x, multiplo, factor: integer;
begin
// obtenemos el valor ingresado por el usuario
x:= StrToInt([Link]);
// asignamos a la variable factor el primer valor que queremos
factor:= 1;
// implementamos el ciclo
repeat
// calculamos el múltiplo correspondiente
multiplo:= x * factor;
// y lo mostramos en el componente que llamamos Memo1
[Link](‘Múltiplo calculado:’ + IntToStr(multiplo));
// incrementamos la variable factor para la siguiente iteración (actualización)
factor:= factor + 1;
until (factor> 10);
end;

11