estructuras de programación - lip.uns.edu.ar · selectivas: las estructuras selectivas se utilizan...
Post on 25-Sep-2018
239 Views
Preview:
TRANSCRIPT
Página 1 de 26
Apunte del curso ALGORITMOS y PROGRAMACIÓN (FI-UBA, Prof. Ing. F. J. LAGE, J. T. P. Ing. Z. CATALDI; A.T.P. Srta. A Pauluzzi, Sr. C Corradino, Sr. F Gómez
Estructuras de Programación
Todo programa puede ser escrito utilizando solamente tres tipos de estructuras de control
• secuenciales • selectivas • repetitivas
Las estructuras de tipo secuencial se han visto en el práctico anterior. En esta practica veremos los otros dos tipos de estructuras.
Selectivas: Las estructuras selectivas se utilizan para tomar decisiones lógicas; de ahí que se suelan denominar estructuras de decisión o alternativas.
Son dos la sentencia if y la sentencia case.
If esta sentencia, es considerada de alternativa doble ( si se cumple cierta condición entonces ... , sino .... / If ...... then ...... else..... ).
Pseudocódigo en español
si <condición>
entonces < acción S1>
sino <acción S2 >
Código se programa
if <condición>
then < acción S1>
else < acción S2>
Su estructugrama tiene la siguiente forma
if <condición> then
< acción S1>
else
< acción S2>
Ejemplos: a) Se leen dos valores enteros A, B. Si A es mayor que B se realiza la suma de ambos,
caso contrario, se hace el producto.
Página 2 de 26
Pseudocódigo del programa
Diagrama N-S
nombre selección1(program); nombre selección1 declaraciones (uses)
Crt, Dos; declaraciones
Crt, Dos
variables (var); A (valor que ingresa) : entero;
Variables A, B, R :enteros
B (valor que ingresa) : entero; funciones y procedimientos R (resultado de la oper.): entero comienzo (programa)
funciones(function); limpieza procedimientos (procedure); ingreso inicio (begin); alternativa
limpieza(limpia la pantalla); resultado ingreso; fin (programa) alternativa (decisión A>B): resultado (salida resultados): Estructura secuencial
fin(end.) Como se puede ver tenemos varios procedimientos ya vistos. Por lo tanto solo se desarrollara el pseudocódigo y el estructurado de alternativa, y todo lo que de el dependa.
algoritmo alternativa
Pseudocódigo del alternativa procedimiento alternativa
inicio (begin); si A > B entonces R ← A + B sino R ← Prod (A, B) fin(end;)
Diagrama N-S
A > B
R ← A + B
else
R ← Prod (A, B)
El código del procedimiento es:
procedure alternativa; {* determina si A es o no mayor que B y hace los cálculos correspondientes *} begin {* comienzo de alternativa *} if A > B then R := A + B else R := Prod (A,B); {* llamado a la función *} end; {* fin de alternativa *}
Nótese que se definió una función Prod (A, B), veremos como se trabaja con ellas.
algoritmo Prod
Página 3 de 26
Pseudocódigo de Prod Diagrama N-S función Prod ( A, B : enteros)entero función Prod ( A, B : entero ) entero
inicio (begin); comienzo (Prod) Prod ← A * B Prod ← A * B
fin(end;) fin (Prod) function Prod ( A, B: integer ): integer; {* obtiene el producto entre dos valores enteros *} begin {* comienzo de Prod *} Prod := A * B; end; {* fin de Prod *} Quedándonos el programa de la siguiente manera.
Program Seleccion_1; {* Este es el primer programa con estructuras de selección y funciones *} uses crt, dos; {* declaraciones *} {const} {* no hay constantes *} var A, B : integer; {* valores que ingresan *} R: integer; {* salida de la operación *} function Prod ( A, B: integer ): integer; {* obtiene el producto entre dos valores enteros *} begin {* comienzo de Prod *} Prod := A * B; end; {* fin de Prod *} procedure limpieza; {* comienzo de limpieza de la pantalla *} begin ClrScr; end; {* fin de limpieza de la pantalla *} procedure ingreso; {* comienzo del ingreso de datos *} begin write ('Ingrese A '); {* ingreso de variable A *} readln (A); write ('Ingrese B '); {* ingreso de variable B *} readln (B); end; {* fin del ingreso de datos *} procedure alternativa; {* determina si A es o no mayor que B y hace los cálculos correspondientes *} begin {* comienzo de alternativa *} if A > B then R := A + B else R := Prod (A,B); {* llamado a la función *} end; {* fin de alternativa *} procedure resultado; {* comienzo la impresión de los resultados *} Var H :char;
Página 4 de 26
begin writeln ( 'Resultado = ', R); writeln ( 'Presione cualquier tecla '); readln (H); {* esta instrucción y la anterior son para dar tiempo para ver resultados *} end; {* fin de la impresión de los resultados *} begin limpieza; {* llamado al procedimiento limpieza *} ingreso; {* llamado al procedimiento ingreso *} alternativa; {* llamado al procedimiento alternativa *} resultado; {* llamado al procedimiento resultado *} end.
b) Se leen dos valores enteros A, B. Si A es mayor que B se realiza la suma de ambos y se imprime un cartel diciendo R es la suma de A y B = , caso contrario, se hace el producto y se imprime otro cartel que diga R . es el producto de A y B =
Página 5 de 26
Pseudocódigo del programa
nombre selección2program);
declaraciones (uses); Crt, Dos;
variables (var); A (valor que ingresa) : entero; B (valor que ingresa) : entero; R (resultado de la oper.): entero
funciones(function);
procedimientos (procedure);
inicio (begin); limpieza (limpia la pantalla) ; ingreso (ingreso de datos); alternativa (decisión A>B e imp.); resultado ( para ver los resultados): fin(end.)
Diagrama N-S
nombre selección1 declaraciones Crt, Dos; Variables A, B, R :enteros funciones y procedimientos comienzo (programa) limpieza ingreso alternativa resultado fin (programa)
Como se puede ver dentro de alternativa se colocó la impresión de resultados quedándonos este algo-ritmo estructurado de la siguiente manera.
algoritmo alternativa
Pseudocódigo del alternativa procedimiento alternativa
inicio (begin); si A > B entonces R ← A + B Imprimir cartel suma y resultados sino R ← Prod (A, B) Imprimir cartel producto y resulta-dos fin(end;)
Diagrama N-S
A > B
R ← A + B
Imp. cartel y resultados
Else
R ← Prod (A, B)
Imp. cartel y resultados
El código del procedimiento es:
procedure alternativa; {* determina si A es o no mayor que B y hace los cálculos correspondien-tes *} begin {* comienzo de alternativa *} if A > B then begin {* comienzo del then *} R := A + B; writeln ( 'R es la suma de A y B = ', R); end {* fin del then *} else begin {* comienzo del else *} R := Prod (A,B); {* llamado a la función *} writeln ( 'R es el producto de A y B = ', R); end; {* fin del else *}
Página 6 de 26
end; {* fin de alternativa *}
Quedándonos el programa de la siguiente manera. Program Seleccion_2; {* Este es el primer programa con estructuras de selección y funciones *} uses crt, dos; {* declaraciones *} {const} {* no hay constantes *} var A, B : integer; {* valores que ingresan *} R: integer; {* salida de la operación *} function Prod ( C, D: integer ): integer; {* obtiene el producto entre dos valores enteros *} begin {* comienzo de Prod *} Prod := C * D; end; {* fin de Prod *} procedure limpieza; {* comienzo de limpieza de la pantalla *} begin ClrScr; end; {* fin de limpieza de la pantalla *} procedure ingreso; {* comienzo del ingreso de datos *} begin write ('Ingrese A '); {* ingreso de variable A *} readln (A); writeln ('Ingrese B '); {* ingreso de variable B *} read (B); end; {* fin del ingreso de datos *} procedure alternativa; {* compara A con B y hace los cálculos e imprime resultados *} begin {* comienzo de alternativa *} if A > B then begin {* comienzo del then *} R := A + B; writeln ( 'R es la suma de A y B = ', R); {* imprime resultados *} end {* fin del then *} else begin {* comienzo del else *} R := Prod (A,B); {* llamado a la función *} writeln ( 'R es el producto de A y B = ', R); {* imprime resultados *} end; {* fin del else *} end; {* fin de alternativa *} procedure resultado; {* comienzo la muestra de los resultados *} Var H :char; begin writeln ( 'Preione cualquir tecla '); readln (H); {* esta instrucción y la anterior son para dar tiempo para ver resultados *} end; {* fin de la muestra de los resultados *}
Página 7 de 26
begin limpieza; {* llamado al procedimiento limpieza *} ingreso; {* llamado al procedimiento ingreso *} alternativa; {* llamado al procedimiento alternativa *} resultado; {* llamado al procedimiento resultado *} end.
Hay varias cosas para tomar en cuenta cuando en alguna de las opciones tiene más de una instruc-ción dicha opción deberá llevar un begin con su correspondiente end. Debe notarse que el end del then no tiene puntuación en cambio el del else si lleva punto y coma (;) esto se debe que este end es el últi-mo del if.
También debe notarse que las variables del llamado de la función son distintas a las de la función en si.
R := Prod (A,B); function Prod ( C, D: integer ): integer; Tanto en funciones como en procedimientos esto es posible ya que el lenguaje vincula automática-
mente la primera variable del llamado con la primera de la declaración, la segunda con la segunda y así sucesivamente. Esto nos permite llamar a una función (o procedimiento), con distintos juegos de varia-bles. Sin que tengamos que atenernos a nombres específicos. Solo debemos tener en cuenta que las variables sean del mismo tipo.
Mútiples salidas : Si se tiene más de dos posibles salidas, aquí aparecen dos soluciones similares al
problema. IF anidado : en esta solución se utiliza un if dentro de otro. Siempre se anida por la salida Else (si-
no). Ejemplo : Se pide un programa donde ingresa un número entre 1 y 5 incluidos ambos y se imprime
en pantalla su expresión de caracteres ( ingresa 2 → imprime Dos). En este caso tenemos cinco salidas probables (uno, dos, tres, cuatro o cinco), esto indica que debe-
remos tener 4 if anidados. Si a = 1 Entonces impre = Uno Sino Si a = 2 Entonces impre = Dos Sino Si a = 3 Entonces impre = Tres Sino Si a = 4 Entonces impre = Cuatro Sino impre = Cinco fin_si {* fin_si no tiene equivalente en Pascal *} fin_si fin_si fin_si
if <condición> then
< acción S1>
else
Página 8 de 26
if <condición> then
< acción S2>
Else
If <condición> then
< acción S3>
Else
If <condición> then
< acción S3>
Else
< acción S4> El código del procedimiento es:
procedure alternativa; {* determina el valor de A y lo expresa en letras *} begin {* comienzo de alternativa *} if A = 1 then {* pregunta por uno *} writeln ( 'U n o ') {* salida por uno *} else if A = 2 then {* pregunta por dos *} writeln ( 'D o s ') {* salida por dos *} else if A = 3 then {* pregunta por tres *} writeln ( 'T r e s ') {* salida por tres *} else if A = 4 then {* pregunta por cuatro *} writeln ( 'C u a t r o ') {* salida por cuatro *} else writeln ( 'C i n c o '); {* salida por cinco *} end; {* fin de alternativa *}
Quedándonos el programa de la siguiente manera.
Program Seleccion_3; {* If anidados *} uses crt, dos; {declaraciones} {const} {* no hay constantes *} var A : integer; {* valor que ingresa *} procedure limpieza; {* comienzo de limpieza de la pantalla *} begin ClrScr; end; {* fin de limpieza de la pantalla *}
Página 9 de 26
procedure ingreso; {* comienzo del ingreso de datos *} begin write ('Ingrese un numero de 1 a 5 : '); {* ingreso de variable A *} readln (A); end; {* fin del ingreso de datos *} procedure alternativa; {* determina el valor de A y lo expresa en letras *} begin {* comienzo de alternativa *} if A = 1 then {* pregunta por uno *} writeln ( 'U n o ') {* salida por uno *} else if A = 2 then {* pregunta por dos *} writeln ( 'D o s ') {* salida por dos *} else if A = 3 then {* pregunta por tres *} writeln ( 'T r e s ') {* salida por tres *} else if A = 4 then {* pregunta por cuatro *} writeln ( 'C u a t r o ') {* salida por cuatro *} else writeln ( 'C i n c o '); {* salida por cinco *} end; {* fin de alternativa *} procedure resultado; {* se utiliza para dejar en pantallas los resultados *} Var H :char; begin writeln ( 'Preione cualquir tecla '); readln (H); {* esta instrucci¢n y la anterior son para dar tiempo para *} {* ver resultados *} end; {* fin de resultado *} begin limpieza; ingreso; alternativa; resultado; end.
Select : esta solución se utiliza en reemplazo del if anidado. Es más práctica y eficiente. su pseudocódigo genérico es:
según...sea E hacer E1: sentencia 1 E2: sentencia 2 E3: sentencia 3 ......................... ......................... En: sentencia n [sino sentencia x ] fin...según
Página 10 de 26
Case <variable> of
Opción1
< acción S1>
Opción2
< acción S2>
Opción n
< acción n>
........
< acción .......>
else
< acción S m>
Para el problema anterior su pseudocódigo será:
según...sea A hacer 1: Imprimir “U n o” 2: Imprimir “D o s” 3: Imprimir “T r e s” 4: Imprimir “C u a t r o” sino Imprimir “C i n c o” fin...según
y su diagrama N - S es:
Case A of
1
Imprimir “UNO”
2
Imprimir “DOS”
3
Imprimir “TRES”
4
Imprimir “CUATRO”
else
Imprimir “CINCO”
Página 11 de 26
El código del procedimiento es:
procedure seleccion; {* determina el valor de A y hace su valor a letras *} begin {* comienzo de alternativa *} case A of {* comienza seleccion *} 1 : writeln ( 'U n o '); {* salida por uno *} 2 : writeln ( 'D o s '); {* salida por dos *} 3 : writeln ( 'T r e s '); {* salida por tres *} 4 : writeln ( 'C u a t r o '); {* salida por cuatro *} else writeln ( 'C i n c o '); {* salida por cinco *} end; {* fin del case *} end; {* fin de alternativa *}
Quedándonos el programa de la siguiente manera. Program Seleccion_4; {* Uso de selectores *} uses crt, dos; {declaraciones} {const} {* no hay constantesr *} var A : integer; {* valor que ingresa *} procedure limpieza; {* comienzo de limpieza de la pantalla *} begin ClrScr; end; {* fin de limpieza de la pantalla *} procedure ingreso; {* comienzo del ingreso de datos *} begin write ('Ingrese un numero de 1 a 5 : '); {* ingreso de variable A *} readln (A); end; {* fin del ingreso de datos *} procedure seleccion; {* determina el valor de A y hace su valor a letras *} begin {* comienzo de alternativa *} case A of {* comienza seleccion *} 1 : writeln ( 'U n o '); {* salida por uno *} 2 : writeln ( 'D o s '); {* salida por dos *} 3 : writeln ( 'T r e s '); {* salida por tres *} 4 : writeln ( 'C u a t r o '); {* salida por cuatro *} else writeln ( 'C i n c o '); {* salida por cinco *}
Página 12 de 26
end; {* fin del case *} end; {* fin de alternativa *} procedure resultado; {* se utiliza para dejar en pantallas los resultados *} Var H :char; begin writeln ( 'Preione cualquir tecla '); readln (H); {* esta instrucci¢n y la anterior son para dar tiempo para *} {* ver resultados *} end; {* fin de resultado *} begin limpieza; ingreso; seleccion; resultado; end.
Resumen: Existen tres tipos de estructuras selectivas
a) If b) If anidado c) case
Cada uno tiene su aplicación específica y se debe tener cuidado si se tiene por salida una o más sen-tencias. (Si hay más de una sentencia por salida colocar Begin End ).
Página 13 de 26
Condicionales
1. Ingresar valores numéricos enteros A, B, C, D, E y decir si su promedio es mayor que o igual a 10.
2. Ingresar valores numéricos reales A, B, C, y decir si su promedio es mayor que o igual a 10.
3. Ingresar valores numéricos reales a, b, c, que son coeficientes de una ecuación cuadrática y obtener los valores X1 y X2 reales. Si la operación dentro de la raíz diera como resultado un valor negativo, imprimir un cartel que diga “La solución son dos números complejos conjugados”.
4. Ingresar valores numéricos reales a, b, c, que son coeficientes de una ecuación cuadrática y obtener los valores X1 y X2 reales. Si la operación dentro de la raíz diera como resultado un valor negativo, imprimir el resultado como “m + n i; m - n i ”.
5. Hacer un programa que permita ingresa un número de 1 a 7 y salga el correspondiente día de la semana ( Ej: 1 → Lunes; 2 → Martes; ...). Si ingresa un valor que no este comprendido entre 1 y 7 deberá imprimir un cartel que diga “ERROR ... valor fuera de rango”
6. Hacer un programa que permita ingresa dos números reales y el símbolo de la operación. Obteníen-dose el correspondiente resultado. Si el símbolo no es correcto, deberá imprimir un mensaje que in-dique “Error en símbolo”
Página 14 de 26
Hasta ahora hemos visto dos tipos de estructuras de control
• secuenciales • selectivas
En esta practica veremos el tipo de estructura que nos queda. Repetitivas: Las estructuras repetitivas (llamadas también bucles, lazo o ciclo) se utilizan para
realizar varias veces el mismo conjunto de operaciones. Dentro de ellas encontramos aquellas donde la cantidad repeticiones se manejan por un número, las que se realizan hasta que se cumple cierta condi-
ción. Son tres la sentencia for y la sentencia while y la sentencia repeat
For esta sentencia, es un bucle controlado por un contador, denominado variable de control o índi-ce.
Pseudocódigo en español
desde variable (v) = vi hasta vf hacer < acción S1> <acción S2 > .......................
fin desde
Código se programa
for variable (v) = vi to vf do
begin < acción S1> < acción S2> ......................
end
Su estructugrama tiene la siguiente forma
���������������������������������������������������������
������������
��������������������������������
������������������������������
������������������
���������������������������� desde v = vi hasta vf
���������������������������������
���������
����������������������������
������������������������������������������������������
���������
����������������������������
������������������������������������� �����������������������������������
���������������������������������������������������������
������������
��������������������������������
������������������������������������������������������������
< acción S1> <acción S2 > ......................
��������������������
���������������������������������������������������������
������������
��������������������������������
������������������������������
������������������
����������������������������
���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������
������������������
������������������������������������������������������������������������������������������������������������
���������������������������������
���������
����������������������������
������������������������������������������������������
���������
����������������������������
����������������������������������������������������������������������������������������������������������������������������������������������������������������������������
Ejemplos:
a) Hacer un programa que imprima los números de 5 hasta 28.
Página 15 de 26
Pseudocódigo del programa
Diagrama N-S
nombre repetición1(program); nombre selección1 declaraciones (uses)
Crt, Dos; declaraciones
Crt, Dos
constantes(const) A = 5;
Constantes A, B
B = 28; Variables R :entero
variables (var) R (resultado de la oper.): entero
funciones y procedimientos
funciones(function)(NO hay); comienzo (programa) procedimientos (procedure); limpieza inicio (begin); ciclo
limpieza(limpia la pantalla); fin (programa) ciclo (hace ciclo e imprime); salida
fin(end.) Como se puede ver tenemos varios procedimientos ya vistos. Por lo tanto solo se desarrollara el pseudocódigo y el estructurado de ciclo, y todo lo que de el dependa.
algoritmo ciclo
Pseudocódigo del ciclo procedimiento ciclo
inicio (begin); desde R= A hasta B hacer imprimo R fin(end;)
Diagrama N-S ������������
������������ ��������
��������������������������
������������������������ ��������
�������������������������� desde R = A hasta B
������������������
����������
������������������
������������������������������� ����������������������������������������� ��������
�������������������������� imprimir R
�������������������������������������� ��������
��������������������������
������������������������ ��������
��������������������������
���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� ��������
�������������������������������������������������������������������������������������������������
������������������
����������
������������������
���������������������������������������������������������������������������������������������������������������������������������������������������
El código del procedimiento es:
procedure ciclo; {* comienzo el ciclo *} begin for R := A to B do {* se define el ciclo A *} writeln ('Numero ',R ); {* imprime salida *} end; {* fin del ciclo *}
Quedándonos el programa de la siguiente manera. Program Repeticion_1; {* Este es el primer programa con estructuras de repeticion *} uses crt, dos; {declaraciones}
Página 16 de 26
const {* constantesr *} A = 5; B = 28; var R: integer; {* controla el ciclo *} procedure limpieza; {* comienzo de limpieza de la pantalla *} begin ClrScr; end; {* fin de limpieza de la pantalla *} procedure ciclo; {* comienzo el ciclo *} begin for R := A to B do {* se define el ciclo A *} writeln ('Numero ',R ); {* imprime salida *} end; {* fin del ciclo *} procedure salida; {* comienzo del procedimiento salida *} {*solo sirve para ver los resultados *} Var H :char; begin writeln ( 'Preione cualquir tecla '); readln (H); {* esta instrucci¢n y la anterior son para dar tiempo para *} {* ver resultados *} end; {* fin del procedimiento salida *} begin limpieza; ciclo; salida; end.
b) Hacer un programa que calcule e imprima el factorial de los números 1 a 7
Página 17 de 26
Pseudocódigo del programa
Diagrama N-S
nombre repetición2(program); nombre selección1 declaraciones (uses)
Crt, Dos; declaraciones
Crt, Dos
constantes(const) A = 1;
Constantes A, B
B = 7; Variables R, Fac :entero
variables (var) R, Fac (resultado de la oper.): entero
funciones y procedimientos
procedimientos (procedure); comienzo (programa) inicio (begin); limpieza
limpieza(limpia la pantalla); ciclo2 ciclo2 (hace ciclo e imprime); salida salida fin (programa)
fin(end.)
pseudocódigo y el estructurado de ciclo, y todo lo que de el dependa.
algoritmo ciclo
Pseudocódigo del ciclo procedimiento ciclo inicio (begin); desde R= A hasta B hacer Fac ← Fac * R imprimo Fac fin_desde fin(end;)
Diagrama N-S ������������
������������
��������
��������������������������
��������������
������������������������
��������
��������������������������
�������������� desde R = A hasta B
������������������
����������
������������������
��������������
������������������������������� �����������������
������������������������ ��������
��������������������������
�������������� Fac ← Fac * R
imprimir Fac .
��������������
������������������������ ��������
��������������������������
������������������������ ��������
��������������������������
���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� ��������
�������������������������������������������������������������������������������������������������
������������������
����������
������������������
���������������������������������������������������������������������������������������������������������������������������������������������������
Como se puede ver dentro del ciclo se hace dos procesos, el cálculo del factorial y la impresión del re-sultados quedándonos este algoritmo estructurado.
El código del procedimiento es:
procedure ciclo; {* comienzo el ciclo *} begin Fac := 1; for R := A to B do {* se define el ciclo A *} begin Fac := Fac * R; {* Calcula factorial *} writeln ('Numero : ',R, ' Factorial : ',Fac ); {* imprime salida numero y factorial *} end end; {* fin del ciclo *}
Como se puede observar el se necesitó colocar un begin y un end para definir comienzo y fin del ciclo, ya que el mismo tiene más de una instrucción. Fac se define igual a uno, porque sino el producto nos daria siempre 0 (cero). Quedándonos el programa de la siguiente manera.
Página 18 de 26
Program Repeticion_2; {* Este es el segundo ejemplo de For *} uses crt, dos; {declaraciones} const {* constantesr *} A = 1; B = 7; var R, Fac : integer; {* controla el ciclo *} procedure limpieza; {* comienzo de limpieza de la pantalla *} begin ClrScr; end; {* fin de limpieza de la pantalla *} Procedure ciclo; {* comienzo el ciclo *} begin Fac := 1; for R := A to B do {* se define el ciclo A *} begin Fac := Fac * R; {* Calcula factorial *} writeln ('Numero : ',R, ' Factorial : ',Fac ); {* imprime salida numero y factorial *} end end; {* fin del ciclo *} procedure salida; {* comienzo del procedimiento salida *} {* solo sirve para ver resultados *} Var H :char; begin writeln ( 'Preione cualquir tecla '); readln (H); {* esta instrucci¢n y la anterior son para dar tiempo para *} {* ver resultados *} end; {* fin del procedimiento salida *} begin limpieza; ciclo; salida; end.
Hay que tomar en cuenta que los ciclos cumplen con las mismas reglas que las opciones “tiene más
de una instrucción el ciclo deberá llevar un begin con su correspondiente end cuando se tenga más de una instrucción.“.
Si fuera B > A el for seria for K = A donwto B do
Página 19 de 26
Bucles controlados por una bandera (While - Repeat) Estos bucles no se repiten una cantidad definida de veces, sino se realizan hasta
que se cumple una cierta condición. La diferencia entre ambos bucles (While y Repeat) es cuando se realiza la pregunta de la condición.
While : en este ciclo la pregunta de condición se hace cada vez antes de comenzar el ciclo. Ejemplo : Se pide un programa donde ingresan una serie de números, el último es un valor negati-
vo. Se pide calcular el promedio de los valores positivos (no incluir el último valor), e imprimir los va-lores y su promedio.
En este caso tenemos que pautar si el último valor lo imprimimos o no. (si optamos por imprimirlo),
esto implicará el siguiente pseudocódigo.
Página 20 de 26
Pseudocódigo del ciclo procedimiento ciclo inicio (begin); N ← 0 S ← 0 leo A imprimo A mientras A >= 0 hacer comenzar S ← S + A N ← N + 1 leo A imprimo A terminar fin(end;)
Diagrama N-S
N ← 0 S ← 0 Leo A Imprimo A ������������
������������ ��������
��������������������������
������������������������ ��������
�������������������������� mientras A >= 0 hacer
������������������
����������
������������������������������
������������ ��������
�������������������������� S ← S + A
��������������������������������������������������
������������
�������������������������������� N ← N + 1
��������������
������������������������ ��������
������������ Leo A
�������������������������������������� ��������
�������������������������� Imprimo A .
��������������
Como se puede ver dentro del ciclo se hace dos procesos, el cálculo del factorial y la impresión del re-sultados quedándonos este algoritmo estructurado.
El código del procedimiento es:
procedure ciclo; {* comienzo de ciclo *} begin S := 0; N := 0; write ( 'Ingrese un valor '); read (A); {* esta instrucci¢n y la anterior son el ingreso de datos *} writeln ( 'El valor es : ',A ); {* esta instrucci¢n imprime el valor *} WHILE A >= 0 DO {* se define el ciclo *} begin {* comienzo de While *} S := S + A; {* Calcula la suma de valores *} N := N + 1; {* Calcula la cantidad de valores *} writeln ; {* Salta una linea *} write ( 'Ingrese un valor '); read (A); {* esta instruccion y la anterior son el ingreso de datos *} writeln ( 'El valor es : ',A ); {* esta instrucci¢n imprime el valor *} end {* fin de While *} end; {* fin de ciclo *}
Quedándonos el programa de la siguiente manera.
Program Repeticion_3; {* Este es el ejemplo de While *} uses crt, dos; {declaraciones} {const} {* constantes no hay*} var A, N, S : integer; {* controla el ciclo *} Prom :real;
procedure limpieza; {* comienzo de limpieza de la pantalla *} begin ClrScr; end; {* fin de limpieza de la pantalla *}
Página 21 de 26
procedure ciclo; {* comienzo de ciclo *} begin S := 0; N := 0; write ( 'Ingrese un valor '); read (A); {* esta instrucción y la anterior son el ingreso de datos *} writeln ( 'El valor es : ',A ); {* esta instrucción imprime el valor *} WHILE A >= 0 DO {* se define el ciclo *} begin {* comienzo de While *} S := S + A; {* Calcula la suma de valores *} N := N + 1; {* Calcula la cantidad de valores *} writeln ; {* Salta una linea *} write ( 'Ingrese un valor '); read (A); {* esta instrucci¢n y la anterior son el ingreso de datos *} writeln ( 'El valor es : ',A ); {* esta instrucci¢n imprime el valor *} end {* fin de While *} end; {* fin de ciclo *} procedure promedia; {* comienzo de promedia *} begin Prom := S / N; {* Calcula el promedio *} writeln ; {* Salta una linea *} writeln ; {* Salta una linea *} writeln ( 'Promedio es = ', Prom:5:2 ); {* Imprime el promedio *} end; {* fin de promedia *} procedure salida; {* comienzo del procedimiento salida *} {* solo sirve para ver resultados *} Var H :char; begin writeln ( 'Preione cualquir tecla '); readln (H); {* esta instrucci¢n y la anterior son para dar tiempo para *} {* ver resultados *} end; {* fin del procedimiento salida *} begin limpieza; ciclo; promedia; salida; end.
En el procedimiento promedia en la escritura del promedio, aparece
writeln ( 'Promedio es = ', Prom:5:2 ); {* Imprime el promedio *}
donde Prom:5:2 significa que la variable Prom será escrita en un formato de 5 caracteres, de los cuales 2 corresponden a los decimales, se necesita un carácter para el punto decimal.
Repeat : esta solución se utiliza cuando el ciclo debe incluir el último valor ingresado. Ya que la pre-gunta se hace al final del ciclo.
Ejemplo : Se ingresan una serie de números distintos, el último es el valor 12. Se pide un programa
que calcule el promedio de los valores (incluir el último valor), e imprimir los valores y su promedio. Pseudocódigo del ciclo procedimiento ciclo
inicio (begin);
Página 22 de 26
N ← 0 S ← 0 repetir leo A imprimo A S ← S + A N ← N + 1 hasta_que A = 12 fin(end;)
Diagrama N-S
N ← 0 S ← 0 ������������
������������ ��������
������������ Leo A ������������
������������
��������
������������
Imprimo A
��������������������������������������������������
������������
�������������������������������� S ← S + A
��������������
������������������������ ��������
�������������������������� N ← N + 1.
�������������������������������������� ��������
��������������������������
������������������������ ��������
�������������������������� hasta_que A = 12
������������������
����������
������������������
��������������
El código del procedimiento es:
procedure ciclo; {* comienzo el ciclo *} begin S := 0; N := 0; repeat {* comienza ciclo *} write ( 'Ingrese un valor '); read (A); {* esta instrucci¢n y la anterior son el ingreso de datos *} writeln ( 'El valor es : ',A ); {* esta instrucci¢n imprime el valor *} writeln ; {* Salta una linea *} S := S + A; {* Calcula la suma de valores *} N := N + 1; {* Calcula la cantidad de valores *} until A = 12; {* definicion al final del ciclo *} end; {* fin del ciclo *}
Quedándonos el programa de la siguiente manera. Program Repeticion_4; {* Este es el ejemplo de Repeat - Until *} uses crt, dos; {declaraciones} {const} {* constantesr no hay*} var A, N, S : integer; {* controla el ciclo *} Prom :real; procedure limpieza; {* comienzo de limpieza de la pantalla *} begin ClrScr; end; {* fin de limpieza de la pantalla *} procedure ciclo; {* comienzo el ciclo *} begin S := 0; N := 0; repeat {* comienza ciclo *} write ( 'Ingrese un valor '); read (A); {* esta instrucci¢n y la anterior son el ingreso de datos *}
Página 23 de 26
writeln ( 'El valor es : ',A ); {* esta instrucci¢n imprime el valor *} writeln ; {* Salta una linea *} S := S + A; {* Calcula la suma de valores *} N := N + 1; {* Calcula la cantidad de valores *} until A = 12; {* definicion al final del ciclo *} end; {* fin del ciclo *} procedure promedia; {* comienzo de promedia *} begin Prom := S / N; {* Calcula el promedio *} writeln ; {* Salta una linea *} writeln ; {* Salta una linea *} writeln ( 'Promedio es = ', Prom:5:2 ); {* Imprime el promedio *} end; {* fin de promedia *} procedure salida; {* comienzo del procedimiento salida *} {* solo sirve para ver resultados *} Var H :char; begin writeln ( 'Preione cualquir tecla '); readln (H); {* esta instrucci¢n y la anterior son para dar tiempo para *} {* ver resultados *} end; {* fin del procedimiento salida *} begin limpieza; ciclo; promedia; salida; end.
Como se puede observar esta estructura (repeat-until) carece de begin y end, ya que los dos extre-
mos están definidos por el propio ciclo. Anidación
Se pueden colocar un ciclo dentro de otro (anidar), esto quiere decir que una estructura contiene en su interior a otra. Las estructuras pueden ser de igual o de distinto tipo. Siempre que se cumpla con las condiciones que aparecen en la siguientes figuras.
��������
�������� ����
����������������������
�������������������� ��������
��������������������
������������������
������������
���������������������������������������� ��������
��������������������
������������������
������������
���������������������������������������� ��������
��������������������
����������������������������������������������������������������������������������������������������� ����
������������
�������������������� ��������
��������
������������������
������������
�������������������������� ��������
��������
������������������
������������
�������������������������� ��������
��������
����������������������������������
������
������������������
������������������������������
������������
������������
���������������������������
������
������
���������������������������������
������������
������������
���������������������������
������������������
������
���������������������������������
������������
������������
����������������������
���������������� ����
����������������������
�������������������� ��������
��������������������
������������������ ����
��������������
������������������������������������������������ ����
����������������������
�������������������� ��������
��������������������
������������������ ����
�������������� ��������
�������� ����
������������
�������������������� ��������
��������
������������������ ����
���� ��������
�������� ����
������������
�������������������� ��������
��������
������������������ ����
�������������������������� ��������
��������
������������������
������������
�������������������������� ��������
��������
��������������������������������������������������������
������
������������������
������������������������������
������������
������������
���������������������������
������������������
������
���������������������������������
������������
������������
���������������������������
������������������
������
���������������������������������
������������
������������
����������������������
���������������� ����
����������������������
�������������������� ��������
��������������������
������������������
������������
���������������������������������������� ��������
��������������������
������������������
������������
���������������������������������������� ��������
��������������������
����������
anidado
��������������
����������
�����������������������
������������������ ������
�����������������
��������������
����������
�����������������������
������������������ ������
�����������������
��������������
����������
�����������������������
������������������ ������
�����������������
����������������������������������������������������������������������������������������������������
����������
����������
������������������
������
������
��������������
����������
����������
������������������
������
������
��������������
����������
����������
������������������
������
������
����������������������������������
���������������
���������������
���������������������������
���������
���������
������������������������
��������������
����������
����������
������������������ ������
������
��������������
����������
����������
������������������ ������
������
��������������
����������
����������
������������������ ������
������
��������������������������������������
����������
����������
������������������ ������
������
��������������
����������
����������
������������������ ������
������
��������������
����������
����������
������������������ ������
������
���������������������������
����������
����������
������������������ ������
������
��������������������������������������
����������
����������
������������������
������
������
���������������������
���������������
���������������
���������������������������
���������
���������
���������������������
���������������
���������������
���������������������������
���������
���������
���������������������
���������������
���������������
���������������������������
���������
���������
������������������������
��������������
����������
�����������������������
������������������ ������
�����������������
��������������
����������
�����������������������
������������������ ������
�����������������
��������������
����������
�����������������������
������������������ ������
�����������������
�������������
anidado
�������������������� ��������
��������������������
����������������
������������
��������������������������
�������������������� ��������
��������������������
����������������
������������
��������������������������
�������������������� ��������
��������������������
����������������
������������
��������������������������
�����������������������������������������������������������������������������������������������������������
��������
��������
����������������
������������
������������
��������������������
��������
��������
����������������
������������
������������
��������������������
��������
��������
����������������
������������
������������
������������������������������������������
������������
������������
������������������������
������������������
������������������
������������������������������
������������
������������
������������������������
������������������
������������������
������������������������������
������������
������������
������������������������
������������������
������������������
��������������������������
�������������������� ��������
��������
����������������
������������
������������
�������������������� ��������
��������
���������������������������������������������������������� ��������
��������
����������������
������������
������������
�������������������� ��������
��������
����������������
������������
������������
�������������������� ��������
��������
����������������
������������
������������
���������������������������������������������� ��������
��������������������
�������������������� ��������
��������������������
��������������������������������
��������
��������������������
��������������������
��������
��������������������
����������������
������������
��������������������������
��������������������
��������
��������������������
����������������
������������
��������������������������
������������ ������������
�������������������� ��������
��������
�������������������������������������������� ��������
��������������������
����������������
������������
��������������������������
�������������������� ��������
��������������������
����������������
������������
��������������������������
�������������������� ��������
��������������������
����������������
������������
��������������������������
������������
incorrecto
Resumen: Existen tres tipos de estructuras repetitivas
a) For
Página 24 de 26
b) While c) Repeat - until
Cada uno tiene su aplicación específica y se debe tener cuidado cuando se anidan.
Página 25 de 26
Repetitivas
1. Leer una lista de 10 valores enteros. Calcular e informar: a) La suma de los valores positivos. b) El producto de los valores negativos. (Ignorar los valores nulos)
2. a) Ingresar 5 juegos de cuatro valores cada uno. Calcular y emitir. El promedio de cada juego. b) Ingresar N juegos de cuatro valores cada uno. Calcular y emitir. El promedio de cada juego. El proceso finaliza al encontrarse un juego cuyo primer valor es 0.
3. Ingresar dos números enteros positivos y calcular el producto de los mismos por sumas sucesi-vas.
4. Leer una lista de números positivos que finaliza en 0 y emitir el valor mínimo de la lista.
5. Leer una lista de números enteros que finaliza en 0 y emitir el valor máximo de la lista.
6. Ídem 5, emitiendo además la ubicación del máximo dentro de la lista. (Suponer un único máxi-mo).
7. Leer 4 juegos de N valores enteros cada uno, donde N se informa al comienzo de cada juego, y emitir el valor máximo de cada grupo. (Suponer un único máximo ).
8. Dada una lista de valores numéricos positivos, finalizada en 0, indicar si esta ordenada en forma ascendente.
9. Una empresa nos informa para cada uno de sus 20 vendedores: código de vendedor : 3 dígitos importe de ventas del mes : real Se desea emitir el importe máximo de ventas del mes y cuántos vendedores alcanzaron dicho im-porte.
10.En una Central Telefónica se procesan los llamados realizados en la siguiente forma: Por cada llamada se ingresa: código de llamada : 3 dígitos (0 al finalizar el proceso) tipo de día : “1” hábil, “2” feriado duración de la llamada : entero > 0. Siendo los importes Primeros 3’ Minuto Adicional
Página 26 de 26
Días hábiles a 10 a 2 Feriados a 15 a 3 Se deberá emitir: a) El importe a abonar por cada llamada (código - importe). b) La cantidad de llamadas que superen los 3’ c) El % de llamados que superan los 3’ (sobre el total de llamadas infor-madas).
11.Se leen 30 valores enteros (comprendidos entre 5 y 40), que representan la temperatura máxima de cada uno de los días de un mes. Se pide hallar e informar : - La temperatura máxima del mes y el día que se produjo. (Se supone única) - Cuántos días la temperatura supero los 25º C. - El promedio de las temperaturas máxima del mes.
12.Se ingresan los resultados de la evaluación de un curso de Programación ; por cada alumno se informa: número de matricula : 4 dígitos (1-9999) asistencia : 1, presente; o, ausente calificación : 2 dígitos (0-10). A partir de esta información se debe calcular e informar: a) Cantidad y % de alumnos presentes. b) Promedio de calificaciones de alumnos presentes. c) % de alumnos aprobados (sobre el total de alumnos presentes). d) Numero de matricula del alumno de mayor calificación. (Si hay varios alumnos con esa califi-cación: numero de matricula y cantidad de alumnos en esa situación).
top related