6-ESTRUCTURA DE CONTROL DE REPETICIÓN
CICLO FOR
La estructura de repetición for maneja de manera automática todos los detalles de la repetición controlada por contador.
Funciona de la siguiente manera:
1. El valor inicial de la variable solo se ejecuta una vez al inicio del ciclo.
2. Se ejecuta la condición.
3. Si es verdadera pasará a ejecutar el cuerpo del for.
4. Se ejecuta el incremento o decremento de la variable.
5. Pasa a preguntar por la condición, resultando así un proceso recursivo.
6. Si la condición fuera falsa la ejecución pasará a la siguiente instrucción.
La forma general de la sentencia for es:
for (inicialización; condición; incremento/decremento)
sentencia;
Esta formada por lo siguiente:
· inicialización es una sentencia de asignación que el compilador usa para establecer la variable de control del ciclo.
· condición es una expresión que comprueba la variable de control del ciclo cada vez para determinar cuándo debe salir del ciclo.
· incremento/decremento define la manera en que cambia la variable de control de ciclo cada vez que la computadora repite el mismo.
El ciclo for continuará la ejecución mientras la condición sea verdadera. Una vez que es falsa, la ejecución del programa continuará en la sentencia que sigue en el programa.
Ejemplo:
Int x
for ( x = 0; x <= 100; x++){
cout<<x+1;
}
WHILE
Permite que se repita cierta acción en cuanto la condición evaluada sea verdadera y en el momento en que la condición sea falsa saldrá del ciclo y continuara con la siguiente instrucción.
La forma general de la sentencia while es:
while ( condición )
sentencia;
Dentro del cuerpo del while se incluye la condición para aumentar la variable de control y asi puede ejecutarse correctamente el ciclo.
{
char c;
ch = ‘ \0 ‘;
while (ch ! = ‘A’ )
ch = getche ( );
}
El ciclo for funciona de la siguiente manera:
1.-Comienza comprobando la condición con la inicialización de la variable.
2.- Determina si es verdadera y el ciclo comienza.
3.-si la condición llega a ser falsa el bucle termina.
DO – WHILE
El funcionamiento de la estructura es sililar a while, la diferencia es que la condiccion se evalua al final de la estructura.
Así que en esta estructura se ejecuta por lo menor una sola vez la(s) sentencia(s).
La forma general de la sentencia do-while es:
do {
sentencia;
}while (condición);
Ejemplo:
int num;
do{
cin >> num;
}while ( num > 100 );
Estructura de Control de Repetición (Repeat)
Estimados lectores el día de hoy
seguimos hablando de estructuras de programación, pero en esta ocasión
dejaremos las formas simples y nos introduciremos o adentraremos a explicar una
estructura de programación con un lenguaje llamado C++. Como se pueden dar
cuenta en la imagen esa es la representación en grafica de un diagrama de flujo
de una acción u orden dada a un equipo para que este nos de un resultado ya sea
falso o verdadero. Pero antes de proseguir la explicación debemos indicar un
breve Glosario para quen entendamos ciertos tecnicismos, para no confundirnos y
entendernos mejor.
Glosario:
Bucle: ciclo
Ciclo: repetición
Do: hacer
Sentencia: resta, suma, multiplicar, dividir, etc.
White: expresión o condición.
Estructura de Control de Repetición
While: se ejecuta mientras la
condición sea verdadera y dentro del bucle debe existir, por lo menos una
sentencia que modifique el valor de la variable o expresión de lo contrariose
puede producir una situación de bucle infinito. Si la expresión lógica es falsa
al comenzar el bucle, este no se realizara.
For: repite la ejecución de una o
varios números de veces, de forma fija previamente establecido. Necesita una
variable de control toma una serie consecutiva de valores de tipo ordinal
comprendidos entre dosnvalores extremos inferior o exterior.
Do While: hacer
mientras.
Repeat: Es el conjunto o
utilizando un par o una parte de las arriba mencionadas, ya la estructura
Repeat es donde se ejecutan siempre una vez por lo menos y la terminaciOn del
bucle se produce cuando el valor de la expresión lógica o condición de salida
es verdadeda. Se ejecuta hasta que la expresión es verdadera, es decir, se
ejecutan mientras la expresión sea falsa o igual.
Ahora
bien el lenguaje que manejaremos a continuación en los ejemplos es el de C++,
que es un lenguaje de programación empleado para dar ordenes a un equipo de
computo y crear con ello un programa, ecuación, dato o una app.
Ejemplos:
Usando
White Si
queremos leer una serie de enteros y encontrar su suma, parando cuando se lea
un número negativo, podemos hacer: sum =
0;
cin »
i;
while (i > =0){
sum = sum + i; cin
» i;
}
Usando
do white
do
{
cout «
"Introduzca un numero entre 1 y 10 " « end1;
cin » numero ; }
while (!((1<= numero)88 (numero < =10)));
Usando
for
int
limite = 1;
int i; for
(i = 0; i< = limite; i++) { cout«
i «end1;
limite++; Esta
estructura producira una secuencia infinita de enteros.
Combinando
varias estructuras
Encuentra
el primer número perfecto mayor que 28, que es 496 ( Un número perfecto es
aquel para el que la suma de todos sus divisores es igual al valor de dicho
número)
int
main ( ) {
bool
encontrado;
unsigned
int intento, cont, suma;
encontrado
= false;
intento =
29;
while
(!encontrado) {// hasta que encontremos el numero suma = 1;
for (cont =2; cont <intento; cont++)
if
(!(intento%cont))// si es divisor
suma
=suma+cont;
if (suma==intento) encontrado
= true;
else
intento
= intento+1;
}
cout«"Numero
perfecto mayor que 28 = "«intento« end1;
system
("pause");
retourn 0; }
Una de las características
importantes que se pueden aprovechar de las computadoras es precisamente su
capacidad de repetir la ejecución de secuencias de instrucciones a una gran
velocidad y con alto grado de confiabilidad. Para estos fines, precisamente se
definen en los lenguajes de programación las estructuras de control iterativas.
El objetivo de estas estructuras es permitir la expresión de la repetición de
una secuencia de instrucciones, a estas estructuras se les denomina ciclo, lazo
o bucle.
Estructuras de Control Iterativas
En la vida diaria existen
situaciones que frecuentemente se resuelven realizando una determinada
secuencia de pasos que puede repetirse muchas veces, ejemplo:
El proceso que seguimos para
comer, mientras no se termine la comida.
El proceso de insertar monedas,
hasta que se abone la cantidad necesaria.
Las operaciones que realizamos
para llamar por teléfono, mientras no se logre la comunicación.
Como se puede observar estos son
algoritmos que se hacen cotidianamente, pero tienen la particularidad de que la
ejecución de alguno de sus pasos puede repetirse muchas veces, mientras no se
logre la meta trazada. A este tipo de algoritmo se le conoce como algoritmos
iterativos o repetitivos. En C#, las instrucciones while, do/while, y for,
permiten ejecutar iteraciones, bucles o ciclos. En cada caso se ejecuta un
bloque de instrucciones mientras la condición que se evalúa tome valor
verdadero. Se resalta que cualquiera de las 3 instrucciones cumple con el mismo
objetivo que es el de ejecutar una secuencia de pasos, más de una vez.
La instrucción while
La instrucción while tiene la siguiente sintaxis:
La semántica de la instrucción es
la siguiente:
<condición>. Está
representada por una expresión booleana y mientras se cumpla se ejecutará el
ciclo.
[Bloque de Instrucciones] El
bloque de instrucciones puede estar formado por una o varias instrucciones y es
el conjunto de pasos que se van ejecutar en cada iteración del ciclo.
Para una mayor comprensión se
muestra su representación en un diagrama de actividad.
Esta estructura de control
permite repetir o iterar el [Bloque de Instrucciones] mientras la condición sea
verdadera o dicho de otra manera, estas iteraciones terminarán cuando la
condición sea falsa y entonces se podrá ejecutar la siguiente instrucción
después del while.
Es válido señalar que en esta
instrucción la condición se evalúa al inicio del ciclo por lo que si la primera
vez que se evalúa la condición esta es falsa, el ciclo no llegará a realizarse.
La instrucción
do/while
La estructura de control do/while
es otra sentencia de iteración en la que la condición se evalúa por primera vez
una vez que se haya ejecutado el [Bloque de Instrucciones] y tienen la
siguiente sintaxis:
Su semántica es la misma que la
de la instrucción while y su representación en un diagrama de actividad es la
siguiente:
En esta estructura repetitiva el
bloque de instrucciones siempre se ejecuta al menos una vez pues la condición
se evalúa al final. Una vez realizada la evaluación si el resultado es true, se
vuelve a ejecutar el [Bloque de Instrucciones], en caso contrario se ejecutan
las instrucciones que sigan a continuación saliendo del ciclo. La funcionalidad
de este método será la misma que en el ejemplo con while. La única diferencia
es la forma en que se controla el bucle. En la práctica, verá que la
instrucción while se utiliza más a menudo que la instrucción do – while. El
elegir una instrucción en lugar de la otra es una elección personal. Un aspecto
muy importante a tener presente en los ciclos condicionales es la necesidad de
contemplar dentro del bloque de instrucciones al menos una, que de alguna
manera, altere –en algún momento- el resultado de la expresión booleana. La
explicación sencillamente está dada por el hecho que de no existir esta
instrucción una vez entrada al ciclo este nunca terminaría por lo que se caería
en un ciclo infinito.
La estructura de
control for
Los procesos iterativos que se
han visto hasta ahora terminan por una condición. En muchas situaciones las
iteraciones se realizan un número determinado de veces, muchos autores les
llaman ciclos por conteo pues se conoce de antemano cuántas veces se hará el
proceso que se repite. En este tipo de iteración, siempre se necesita una
variable que lleve el control de las veces que se repite el proceso por esto se
les conoce también como ciclos con variable de control. Uno de los ciclos más
conocidos y usados en la mayoría de los lenguajes de programación es el de la
instrucción for que suele estar controlado por un contador o variable de
control y tiene la siguiente sintaxis:
La semántica de la instrucción es la siguiente:
<instrucciones 1>. Se
ejecutará una sola vez al inicio del ciclo, generalmente se realizan
inicializaciones y declaraciones de variables puesto que como se dijo con
anterioridad, esta solo se ejecuta una vez. En caso de que se quiera realizar o
ejecutar más de una instrucción en este momento, dichas instrucciones se deben
separar por comas (“,”).
<expresión>. Es evaluada en
cada iteración y en dependencia del valor que devuelva, dependerá que el ciclo
continúe ejecutándose (valor de la expresión true) o no (false). Destacar que
de no colocarse nada en esta parte, el ciclo tomará como true el valor de la
expresión por lo que en principio, el ciclo puede estar repitiéndose
infinitamente.
<instrucciones 2>. Es
ejecutado siempre en cada ciclo al terminar de ejecutar todas las instrucciones
que pertenecen al bucle for en cuestión. Por lo general puede contener alguna
actualización para las variables de control. Análogamente a <instrucciones
1> en caso de querer ejecutar en este momento más de una instrucción se
deben separar por comas.
Observe que es obligatorio para
separar cada término que compone la instrucción for utilizar un punto y coma
(;) de lo contrario el compilador mostrará un error de tipo semántico. Reiterar
que la <instrucción 1> se ejecuta una sola vez al comienzo, que la
<instrucción 2> es la que generalmente se utiliza para modificar la
variable de control aunque en el ciclo esta puede modificarse también, y que
<expresión>, es la que garantiza la finitud del ciclo, el for se estará
ejecutando siempre y cuando <expresión> sea evaluada y tome valor true.
Caso de Estudio
Para mejor entendimiento de lo expuesto anteriormente, se
presenta el siguiente caso de estudio en que se trabajará con cada una de las
estructuras repetitivas.
CasoEstudioIteraciones.JPG
MCD()
Para implementar la responsabilidad de la clase de calcular
el Máximo Común Divisor MCD se utilizará el algoritmo de Euclides que consiste
en:
P1: Si los números son iguales, tomar el primer número como
respuesta y concluir la ejecución del algoritmo, en otro caso pasar al paso 2.
P2: Determinar cuál de los dos números es mayor.
P3: Sustituir el número mayor por la diferencia entre los
números mayor y menor.
P4: Pasar al paso 1.
Obsérvese como se repiten los
pasos 1,2 y 3 y el paso 4 consiste precisamente en regresar al paso 1, esta
repetición se conoce normalmente con el nombre de iteración, nótese que esta no
es infinita, precisamente en el primer paso se especifica que los pasos
siguientes (2, 3, 4) han de ejecutarse si no cumple la condición de que los
números sean iguales. Esta condición es una expresión booleana.
Ejecutar el algoritmo para un par
de valores (8 y 20 por ejemplo)
Para implementar el método que
permita calcular el máximo común divisor utilizaremos la estructura de control
while se evaluará la condición de que los números sean diferentes y en
dependencia del resultado de la misma se ejecutarán o no los pasos que forman
parte del ciclo. El método MCD, quedaría de la siguiente manera:
MCD.JPG
CantDigitos()
Para determinar la cantidad de
dígitos que tiene el número, primeramente se divide el número entre 10, si el
cociente de la división es 0, se toma 1 como respuesta, sino, se toma dicho
cociente y se divide entre 10, este proceso se estará repitiendo mientras el
nuevo cociente sea distinto de 0. Como se observa, al menos se necesita
realizar una división, por lo que la estructura do/while es la indicada para
implementar este algoritmo. Para implementar el método hay que tener en cuenta
lo siguiente:
P1: Se realiza la división del número entre 10.
P2: Se almacena el cociente en una variable y se cuenta que
número de división es.
P3: Si el resultado del cociente es distinto de 0, se repite
el paso 1.
El método quedaría de la siguiente manera:
CantDigitos.JPG
Factorial()
Para implementar la última
responsabilidad propuesta, Calcular el Factorial, utilizaremos la estructura de
control for, ya que se conoce de antemano la cantidad de operaciones
(multiplicaciones) que hay que realizar. Recuerde que el factorial de un número
es el resultado de la multiplicación desde 1 hasta el número en cuestión.
Ejemplo: Factorial de 5 es: 1 * 2 * 3 * 4 * 5 = 120
El método quedaría de la siguiente manera.
Ciclos Anidados
En muchos casos de la vida diaria
no basta con repetir un grupo de instrucciones una cantidad de veces sino que
esas repeticiones deben ser realizadas al mismo tiempo un número de ocasiones.
Este tipo de problemas da origen a los algoritmos con ciclos compuestos o
ciclos anidados. Los ciclos anidados o compuestos no son más que ciclos que
tienen otros ciclos dentro del bloque de instrucciones que deben ejecutar. Esta
facilidad de componer uno o más ciclos en combinación con algunas estructuras
de almacenamiento resulta muy útil para la solución de algunos algoritmos de
búsqueda y ordenación que se verán más adelante en el curso. Usualmente los
ciclos que se componen para resolver un algoritmo en particular son los ciclos
por variable de control, lo que no quiere decir que no se pueda hacer con
ciclos con condición o con una combinación de ellos dos, lo que resultan menos
frecuentes estos casos.
Comentarios
Publicar un comentario