Pasar a sus apuntes de programación lo que no tengan de las copias que anteriormente se les dio es una retroalimentación pero mas explicado es para estudiarlo y vienen ejercicios que pueden corregir y modificar si es necesario siempre y cuando resuelva el problema.
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
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>
|
|
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
|
El programa efectúa un total de 5 ciclos,
aunque en este último la condición se
hace falsa por lo que finaliza,
transfiriendo el control a la línea de código que
lee una tecla. La secuencia de eventos es
el siguiente:
|
|
x
0
5
10
15
20
|
condicion
0<20
5<20
10<20
15<20
20<20
|
Acción
Imprime
0
Imprime 5
Imprime 10
Imprime 15
Fin
ciclo for..
|
|
For anidados
|
Un ciclo for puede colocarse
dentro de otro, en este caso el ciclo interno se
ejecutará totalmente cada vez que se
ejecute el ciclo que lo contiene.
Ejemplo:
|
|
#include
<conio.h>
#include
<iostream.h>
|
|
void main()
{
clrscr();
int x,y;
int fin1=6, fin2=5;//Probar con otros valores
for
(x=1;x<=fin1;x++)
{
cout<<"\n";
for (y=1;y<=fin2;y++)
cout<<x*y<<"\t";
}
getch();
}
|
La salida sería:
1 2 3 4 5
2 4 6 8 10
3 6 9 12 15
4 8 12 16 20
5 10 15 20 25
6 12 16 24 30
|
Por cada valor que toma x en el ciclo for externo se efectúa
totalmente el ciclo
for interno es decir y inicialmente toma el
valor de 1 y se imprime 1*1=1,
luego y=2 y se imprime 2, y así
hasta que y=5 imprime 5, en el siguiente
ciclo la condición se hace falsa dándose
por terminado el ciclo interno, pero el
ciclo externo incrementa su valor y
ejecuta nuevamente el ciclo interno, este
proceso se sigue hasta que la condición
del ciclo externo se hace falsa.
|
Do while
|
Difiere tanto de for como de while en que es un ciclo de verificación
posterior, es decir al ciclo se entra al
menos una vez , y la condición del ciclo
se prueba al cabo de la primera iteración.
Como los ciclos do-while se
ejecutan como mínimo una vez, es mejor
utilizarlos en aquellas aplicaciones
en las que se quiere entrar al ciclo.
do
{
Instrucción_1;
Instrucción_2;
}
while(condición);
|
Ejemplo:
|
#include
<conio.h>
#include
<iostream.h>
|
|
void main()
{
clrscr();
char op;
do
{ cout<<" MENU";
cout<<"\n 1.-Altas";
cout<<"\n 2.-Bajas";
cout<<"\n 3.-Consultas";
cout<<"\n 4.-Salir";
cout<<"\nOpcion:";
do
{
op=getch();
}
while(op!='1'&&op!='2'&&op!='3'&&op!='4');
//Código adicional
}
while
(op!='4');
}
La
salida del programa sería:
MENU
1.-Altas
2.-Bajas
3.-Consultas
4.-Salir
Opcion:
|
En este ejemplo se utilizan dos ciclos do-while anidados. El ciclo exterior
controla la terminación del programa y el
ciclo interior valida la opción
seleccionada por el usuario, de tal forma
que si el usuario selecciona una
opción distinta a las permitidas (1,2,3,4)
se vuelve a leer sin salir del ciclo
interior. Solamente si el usuario
selecciona la opción ‘4’ la condición del ciclo
exterior será falsa y finalizará, en caso
contrario desplegará nuevamente el
menú de opciones.
|
Ejemplos:
|
1.- Programa para calcula la calificación
final de un alumno, teniendo como
datos N calificaciones
parciales (3). Imprime el nombre, la calificación final y
un comentario de “Aprobado” si obtiene 70
o más y “Reprobado” en caso
contrario.
|
#include <stdio.h>
#include
<conio.h>
#include
<iostream.h>
|
void main()
{
clrscr();
float Prom,SumCal=0,Cal;
int x;
char Nom[40];
cout<<"DETERMINA SI UN ALUMNO APRUEBA O NO";
cout<<"\n\nNOMBRE DEL ALUMNO: ";
gets(Nom);
for (x=1;x<=N;x++)
{
cout<<"\n CALIFICACION No "<<x<<":
";
cin>>Cal;
SumCal=SumCal+Cal;
}
|
|
Prom=
SumCal/N;
cout<<"\nEL ALUMNO "<<Nom<<" TIENE EL
PROMEDIO DE: "<<Prom<<" Y ESTA:";
if(Prom>=70)
cout<<"\n\nAPROBADO";
else
cout<<"\n\nREPROBADO";
|
getch();
}
|
2.- Programa que calcula el salario de un
empleado, Según el número de horas
trabajadas por semana y el salario por
hora. Si el número de horas trabajadas
es menor o igual a 40 se paga la cuota
normal por hora. Si el número de horas
rebasa las 40 horas reglamentarias, el
excedente se paga como tiempo extra:
1 a 10 hrs. Extras se paga al doble de la cuota por hora
11 a 20 hrs. Extras se paga al triple de la cuota por hora
21 ó más hrs. Extras se paga al cuádruple de la cuota por hora
En ningún caso el número de horas
trabajadas por semana podrá ser superior a
80.
|
/*Salario.cpp */
#include
<stdio.h>
#include
<conio.h>
#include
<iostream.h>
|
|
void main()
{
clrscr();
float SalSem, SalHra, SalTE=0,SalBase;
int Hrs;
char
Nom[40];
cout<<"CALCULA EL SALARIO SEMANAL
DE UN TRABAJADOR";
cout<<"\n\nNOMBRE DEL TRABAJADOR: ";
gets(Nom);
cout<<"\nNo. DE HORAS TRABAJADAS POR SEMANA: ";
do{//Valida el intervalo de Hrs permitidas
cin>>Hrs;
}
while(Hrs<0 || Hrs>80);
cout<<"\nSALARIO POR HORA:";
cin>>SalHra;
if (Hrs<=40)
{
SalBase=Hrs*SalHra;
SalSem=SalBase;
}
else
{
SalBase=40*SalHra;
if (Hrs>40 && Hrs <=50)
SalTE=(Hrs-40)*SalHra*2;
else
if (Hrs>50 && Hrs <=60)
SalTE=(Hrs-40)*SalHra*3;
else
SalTE=(Hrs-40)*SalHra*4;
SalSem=SalBase+SalTE;
}
cout<<"\nTRABAJADOR: "<<Nom;
cout<<"\nSALARIO BASE:"<<SalBase;
cout<<"\nSALARIO POR TIEMPO EXTRA: "<<SalTE;
cout<<"\n_______
";
cout<<"\nSALARIO TOTAL SEMANAL:"<<SalSem;
}
|
|
|
|
|
| | | | | | | | | | | | | | |
|
