Observación: Sus dudas me lo hacen saber en comentarios del blogger.
CONCEPTOS BASICOS
Bucle
El bucle es un conjunto de
instrucciones que se repiten.
Interacción
Es cada una de las veces que se ejecuta
el bucle.
Contador
Un contador
es una variable cuyo valor incrementa o decrementa en una cantidad fija se
utiliza en los siguientes casos.
Para contabilizar el número de veces
que se desea una operación o grupo de operaciones.
Un contador toma un valor inicial antes de empezar
sus funciones y se debe codificar en el siguiente formato:
cont=cont +1
cont=cont -1
|
Donde: cont es el nombre de tu variable contador.
Acumulador
Un
acumulador se encarga de almacenar en una variable el resultado de una o varias
operaciones matemáticas que se encuentran dentro de una sentencia repetitiva,
para obtener un total acumulado.
Un
acumulador se debe inicializar a cero (0) en caso de suma y en uno (1) en caso
de producto y se codifica bajo el siguiente formato:
acum=acum+variable
acum=acum*variable
|
Qué es una estructura repetitiva?
Las estructuras repetitivas se
utilizan cuando se quiere que un conjunto de instrucciones se ejecuten un
cierto número finito de veces, por ejemplo, escribir algo en pantalla cierta
cantidad de veces, mover un objeto de un punto a otro cierta cantidad de pasos,
o hacer una operación matemática cierta cantidad de veces. Se les llama bucle o
ciclo a todo proceso que se repite cierto número de veces dentro de un
pseudocódigo o un programa y las estructuras repetitivas nos permiten hacerlo
de forma sencilla.
Existen diferentes tipos de
estructuras que veremos una a una.
Desde o para (for)
Esta estructura ejecuta las acciones del cuerpo del bucle un número
especificado de veces, y de modo automático controla el número de iteraciones o
pasos.
Desde i=0 hasta 100
Acción_1
Acción_2
Acción_3
Acción_n
Fin_desde
Fin_desde
Mientras (while)
Repite el cuerpo del bucle mientras se cumpla una determinada condición.
Mientras condición
Acción_1
Acción_2
Acción_3
Acción_n
Fin_mientras
Repetir hasta (do while)
La estructura repetir cumple la misma función que la estructura
mientras. La diferencia está en que la estructura mientras comprueba la
condición al inicio y repetir lo hace al final. Es por ello que la estructura
repetir se ejecuta por lo menos una vez.
Hacer
Acción_1
Acción_2
Acción_3
Acción_n
Mientras condición
ESTRUCTURA REPETITIVA: MIENTRAS QUE (while)
La estructura mientras que (while) es aquella en la que el número de
repeticiones de bucle no se conoce por anticipado, y el cuerpo del buque se
repite mientras se cumple una determinada condición.
Ø Condición es una
expresión booleana (puede ver verdadera o falsa) que se evalúa al
principio del bucle y antes de cada iteración de las sentencias.
Ø Si la condición es
verdadera, se ejecuta el bloque de sentencias y se vuelve al principio del
bucle.
Ø Si la condición es falsa, no se ejecuta
el bloque de sentencias y se continúa con la siguiente sentencia del programa.
Una representación grafica seria como sigue:
Pseudocódigo
|
Código
C++
|
Mientras (condición) Hacer
grupo de sentencias
FinMientras
|
while(condicion){
grupo_de_sentecias
}
|
Explicación
·
Después de la sentencia: sentencia_n
se entra a evaluar la condición que esta junto a while, si es falsa se
pasa el control del programa a la sentencia: sentencia_m (fuera de las llaves
como indica la línea de color rojo) para continuar con las otras sentencias…
Por lo tanto no se ingresaría ni una sola ves al grupo de sentencias dentro de
las llaves del while.
·
En caso de que la condición junto
a while sea verdadera se pasa el control del programa al grupo de
sentencias que se encuentran dentro de las llaves (como indica la línea de
color verde), para luego regresar (como indica la línea azul) a
evaluar la condición esto se repite mientras la condición sea verdadera por lo
tanto en el grupo de sentencias que esta dentro de la llaves de: while se
debe de modificar la condición para que en alguna vez la condición evaluada sea
falso y salga del bucle para continuar con la sentencia_ m y las otras que
continúan.
·
Por eso se dice que el bucle while
se ejecuta cero o mas veces.
·
Si la condición nunca llega a ser
falsa, tenemos un bucle infinito.
·
La condición se denomina invariante
del bucle.
Ejemplos.
E1.
Desarrolle
un algoritmo que le permita realizar la escritura de los primeros 100 números
naturales.
Análisis. Para poder escribir los primeros
100 números primeo hay que generar dichos valores, Una forma de generar los
valores es con la estructuras repetitivas. Declaramos una variable que se
inicie con un valor: 1 (int cont=1;) que seria el primer valor a escribir y finaliza
en 100 que seria el último número a escribir necesitando un incremento de uno
en uno en la variable (se usara un contador).
Inicia:
cont=1
Finaliza:
cont=100
Incrementa
cont en uno o sea : cont =cont+1
(Código
compilado en devC++) copie y péguelo en su compilador para
comprovar
#include<iostream.h>
#include<conio.h >
Void main()
{
int
cont=1;
cout<<"Los
primeros 100 numeros naturales";
while(cont<=100)
{
cout<<cont;
cont=cont+1;
};
cout<<"Aqui
ya salio del bucle”;
getch();
}
E2.
Desarrolle un algoritmo que le permita realizar la
suma a los primeros N número impares.
Análisis. Al igual que en el ejercicio
anterior es necesario apoyarse en una estructura de tipo cíclica a fin de poder
dar solución al problema, la idea es desarrollar la estructura para N veces,
una variable que lleve la cuenta para generar los numero impares buscando la
relación entre la cuenta y el número como tal (se usara un contador, y un
acumulador).
(Código
compilado en devC++) copie y péguelo en su compilador para
comprovar
#include<iostream.h>
#include<conio.h>
Void main()
{
int n,num,cont=1,acum=0;
cout<<"Ingrese
un numero : ";
cin>>n;
while(cont<=n){
num=2*cont-1;
cout<<num;
acum=acum+num;
cont=cont+1;
}
cout<<"La
suma de los "<<n<<" Primeros numeros impares es :
"<<acum
getch();
}
Nota. El problema se puede resolver de muchas formas
por ejemplo solo bastaba con elevar al cuadrado en número ingresado, la forma
como se resolvió es para mostrar cómo es que funciona la estructura repetitiva while.
E3.
Desarrolle un algoritmo que calcule el promedio de
los primeros N números naturales.
Análisis. Para dar solución al ejercicio se procede a la
siguiente forma: Se debe generar una estructura repetitiva que se encargue de
contar el número de términos a sumar, en el caso del ejercicio será N.
La variable que se encarga de contar los términos sirve además como generadora
de los términos a sumar. Se acumularan dichos números generados y al final se
promedia dicha sumatoria entre el número de términos sumados.
(Código compilado en devC++) copie y péguelo en su
compilador para comprobar
#include<iostream.h>
#include<conio.h>
Void main()
{
int n,cont,suma;
float promedio;
suma=0;
cont=1;
cout<<"Ingrese
la cantidad de numeros : ";
cin>>n;
while(cont<=n){
suma=suma+cont;
cont++;
};
promedio=suma/n;
cout<<"El
promedio de los numeros es : "<<promedio;
getch()
}
E4.
Desarrolle un algoritmo que le permita leer un
valor entero positivo N y calcule su factorial.
(Código compilado en devC++) copie y péguelo en su
compilador para comprovar
#include<iostream.h>
#include<conio.h>
Void main()
{
int n,factorial=1,i=1;
cout<<"Ingrese un numero : ";
cin>>n;
while(i<=n)
{
factorial=factorial*i;
i++;
};
cout<<"El
factorial es : "<<factorial;
getch();
}
Sentencia For
|
Cuando se desea ejecutar una sentencia
simple o compuesta, repetitivamente
un número de veces conocido, la
construcción adecuada es la sentencia for.
|
|
for(exp_inicialización; condición;
expresión_incremento)
|
instrucciones;
}
El
flujo del bucle FOR transcurre de la siguiente forma:
|
Cuando se encuentra la instrucción for se ejecuta primero la expresión de
inicialización, no volviendo a ejecutarse
más. Generalmente esta instrucción
realiza la inicialización de la variable
de control de ciclo. Tras esto se prueba
la condición. Siempre
que condición se evalúa como verdadero, la instrucción
o instrucciones dentro del ciclo son
ejecutados. Después de entrar en el ciclo
y ejecutar todas las instrucciones dentro
de éste se ejecuta
expresión_incremento. Sin embargo si condición toma el valor Falso, las
instrucciones dentro del ciclo son
ignoradas y la ejecución continúa con la
instrucción al final del ciclo.
Cuando se necesitan ejecutar varias instrucciones dentro del ciclo se
hacen necesarias definir el bloque con las
llaves {}
|
Ejemplo:
|
#include
<conio.h>
#include
<iostream.h>
|
|
void main()
{
clrscr();
|
|
int x, Ini=0, Inc=5, Fin=20; //Probar con
otros valores
for
(x=Ini;x<Fin;x=x+Inc)
cout<<"\t"<<x;
0 5 10 15
|
¿eso quiere decir que solo vamos a corregir los ejercicios en nuestra libreta solo si ya habíamos copiado las copias?
ResponderEliminarDisculpe profe, esto va despues de terminar de copiar las hojas de programacion orientada a objetos? Y para cuando lo revisa?
ResponderEliminarLofiu
Eliminarhola profe, sabe como se pone el switch en el diagrama de flujo
ResponderEliminarplantea 5 recomendaciones para aplicar una estructura repetitiva de forma eficiente en la resolución de un problema.
ResponderEliminar