Escrituras repetitivas
Las estructuras repetitivas son aquellas que sirvenpara evitar la molestia de andar repitiendo una acciones varias veces. Estas sirven para que una acción se ejecute un determinado numero de veces, y depende del cumplimiento de una determinada acciones (una condición).
Las estructuras repetitivas permiten ejecutar acciones que pueden descomponerse en otras acciones primitivas, esta estructura debe tener una entrada y una salida en la cual se ejecute la acción un determinado o indeterminado numero de veces. Las estructuras repetitivas pueden ser :WHILE (mientras), FOR (para), DO WHILE (hacer mientras).
Esta estructura se compone de tres expresiones. La primera expresión es aquella que asigna un valor inicial (acción a ejecutar), la segunda expresión es la que determina como y cuando se continua o no el bucle, una condición que debe ser satisfecha para que se continue la ejecución (expresión lógica), y la tercera expresión permite que el valor inicial (indice) se modifique en cada pasada.
#include<iostream>
#include<stdlib.h>
#include<math.h>
using namespace std;
int main(){
int n,suma=0,elevacion=0;
cout<<"Digite el numero de terminos a sumar: ";
cin>>n;
for(int i=1;i<=n;i++){
elevacion = pow(2,i);
suma += elevacion;
}
cout<<"\nLa suma es: "<<suma<<endl;
system("pause");
return 0;
}
#include<stdlib.h>
#include<math.h>
using namespace std;
int main(){
int n,suma=0,elevacion=0;
cout<<"Digite el numero de terminos a sumar: ";
cin>>n;
for(int i=1;i<=n;i++){
elevacion = pow(2,i);
suma += elevacion;
}
cout<<"\nLa suma es: "<<suma<<endl;
system("pause");
return 0;
}
Estructura mientras (“while”)
ESTRUCTURA DE CONTROL REPETITIVAS
1. Hacer mientras que______(while)
2. Hacer hasta que_________(do_while)
3. Desde o para____________(for)
Bucle
El buque 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
|
Donde: acum es el nombre de tu variable acumulador.
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 evalua 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.
#include<iostream>
#include<stdlib.h>
using namespace std;
int main(){
int n,x=0,y=1,z=1;
do{
cout<<"Digite la cantidad de digitos de la serie: ";
cin>>n;
}while(n<=0);
cout<<"1 ";
for(int i=1;i<n;i++){
z = x + y;
cout<<z<<" ";
x = y;
y = z;
}
cout<<"\n";
system("pause");
return 0;
}
#include<stdlib.h>
using namespace std;
int main(){
int n,x=0,y=1,z=1;
do{
cout<<"Digite la cantidad de digitos de la serie: ";
cin>>n;
}while(n<=0);
cout<<"1 ";
for(int i=1;i<n;i++){
z = x + y;
cout<<z<<" ";
x = y;
y = z;
}
cout<<"\n";
system("pause");
return 0;
}
Una representacion grafica seria como sigue:
Pseudocódigo
|
Código C++
|
Mientras (condicon) 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>
int main(){
int cont=1;
cout<<"Los primeros 100 numeros naturales"<<endl;
while(cont<=100){
cout<<cont<<endl;
cont=cont+1;
};
cout<<"Aqui ya salio del bucle"<<endl;
system("pause");
return 0;
}
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 generara 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>
int main(){
int n,num,cont=1,acum=0;
cout<<"Ingrese un numero : ";
cin>>n;
while(cont<=n){
num=2*cont-1;
cout<<num<<endl;
acum=acum+num;
cont=cont+1;
}
cout<<"La suma de los "<<n<<" Primeros numeros impares es : "<<acum<<endl;
system("pause");
return 0;
}
Nota. El problema se puede resolver de muchas formas por ejemplo solo bastaba con elevar al cuadrado en numero ingresado, la forma como se resolvió es para mostrar como 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 numero de términos sumados.
(Código compilado en devC++) copie y péguelo en su compilador para comprovar
#include<iostream.h>
int main(){
int n,cont,suma;
suma=0;
cont=1;
float promedio;
cout<<"Ingrese la cantidad de numeros : ";
cin>>n;
while(cont<=n){
suma=suma+cont;
cont++;
};
promedio=(1.0)*suma/n;
cout<<"El promedio de los numeros es : "<<promedio<<endl;
system("pause");
return 0;
}
Nota. A la división por (1.0) para que salgan los decimales, cont++ equivale a cont=cont+1
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>
int 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<<endl;
system("pause");
return 0;
}
E5.
Desarrolle un algoritmo que le permita leer un valor entero positivo N y decir si es primo o no.
(Código compilado en devC++) copie y péguelo en su compilador para comprovar
#include<iostream.h>
int main(){
int n,j=2,s=0;
cout<<"Ingrese un numero : ";
cin>>n;
while(j<=n/2){
if(n%j==0){
s++;
}
j++;
};
Bucle infinito
Bucle infinito en programación es un error que consiste en realizar un ciclo que se repite de forma indefinida ya que su condición para finalizar nunca se cumple.1
Por definición un bucle debe contener condiciones que establezcan cuándo empieza y cuándo acaba, de manera que, mientras las condiciones se cumplan, ejecute una secuencia de código de manera repetitiva. En el caso de ciclo infinito, como la condición de finalización no se alcanza, el bucle sigue ejecutando el segmento de código indefinidamente.
/*Ejercicio 4: Rellenar un arreglo con n numeros, posteriormente utilizando punteros
determinar el menor elemento del vector.*/
#include<iostream>
#include<conio.h>
using namespace std;
int main(){
int nElementos,numeros[100],*dir_numeros,menor=999999;
cout<<"Digite el numero de elementos del arreglo: ";
cin>>nElementos;
for(int i=0;i<nElementos;i++){
cout<<i+1<<". Digite un numero: ";
cin>>numeros[i]; //Guardamos los elementos en el arreglo
}
dir_numeros = numeros;
for(int i=0;i<nElementos;i++){//Determinamos el menor elemento en cada
if(*dir_numeros < menor){//iteracion del bucle
menor = *dir_numeros;
}
dir_numeros++;
}
cout<<"\nEl menor elemento es: "<<menor<<endl;
getch();
return 0;
}
determinar el menor elemento del vector.*/
#include<iostream>
#include<conio.h>
using namespace std;
int main(){
int nElementos,numeros[100],*dir_numeros,menor=999999;
cout<<"Digite el numero de elementos del arreglo: ";
cin>>nElementos;
for(int i=0;i<nElementos;i++){
cout<<i+1<<". Digite un numero: ";
cin>>numeros[i]; //Guardamos los elementos en el arreglo
}
dir_numeros = numeros;
for(int i=0;i<nElementos;i++){//Determinamos el menor elemento en cada
if(*dir_numeros < menor){//iteracion del bucle
menor = *dir_numeros;
}
dir_numeros++;
}
cout<<"\nEl menor elemento es: "<<menor<<endl;
getch();
return 0;
}
Estructura hacer_mientras (“do-while”):
(Do-While). Al igual que en la estructura while las instrucciones se ejecutan mientras la condición sea verdadera, pero la condición se comprueba al final del ciclo, por lo que las instrucciones se ejecutarán al menos una vez.
Variable de control: prácticamente un mandato impuesto por el uso habitual es utilizar la letra i Iterador como variable de control, o bien sus sucesoras en caso de bucles anidados. El uso de esta letra críptica quizás a primera vista es sin embargo una excelente forma de aportar agilidad de lectura al código por su uso tan extensivo. Como raras veces los bucles anidados superan las tres dimensiones (por una sencilla cuestión de explosión exponencial), las letras i, j y k suelen ser las únicas relacionadas con este uso. En C se define en el primer parámetro de la instrucción junto con la inicialización (opcional).
Inicialización de la variable de control: en pseudolenguaje se pide explicitarlo (es la sección := ValorInicial), sin embargo, otros lenguajes más permisivos como C no lo requieren de forma obligatoria. De todos modos, la práctica de utilizar variables de control que no se inicializan en el bucle no es recomendada para la legibilidad del código. En C se define en el primer parámetro del bucle junto con la variable de control.
Condición de control: en pseudolenguaje se ve representado por el valor final que puede tomar la variable de control (la sección A ValorFinal). En C es el segundo parámetro y puede ser cualquier condición (ni siquiera es obligación que esté la variable de control, aunque una vez más, esto no se considera una buena práctica).
Incremento: en pseudolenguaje se toma por defecto el valor 1, aunque puede explicitarse por medio de la sentencia PASO = ValorPaso cualquier número entero (léase bien entero, o sea que técnicamente podemos decrementar). En C es el último parámetro.
Cuerpo: es lo que se hará en cada iteración, pueden ser una o más instrucciones. En pseudolenguaje pesa la restricción de no poder alterar el valor de la variable de control; esto no es requerido en C, pero no se considera una buena práctica.
(Do-While). Al igual que en la estructura while las instrucciones se ejecutan mientras la condición sea verdadera, pero la condición se comprueba al final del ciclo, por lo que las instrucciones se ejecutarán al menos una vez.Forma Lógica
Estructura hacer – mientras (do-while)
Ejecuta las instrucciones que hay dentro del ciclo do – while y va al #2.
Evalúa condición del ciclo do –while, caso de que la condición sea
verdadera retorna al #1; en caso de que la condición sea falsa va al #3.
Termina el Ciclo do - while y continua la secuencia del programa.
#include<iostream>
#include<conio.h>
#include<stdlib.h>
using namespace std;
struct Nodo{
char dato;
Nodo *siguiente;
};
//Prototipos de Funciones
void menu();
void insertarCola(Nodo *&,Nodo *&,char);
bool cola_vacia(Nodo *);
void suprimirCola(Nodo *&,Nodo *&,char &);
int main(){
menu();
getch();
return 0;
}
void menu(){
int opc;
char dato;
Nodo *frente = NULL;
Nodo *fin = NULL;
do{
cout<<"\t.:MENU:.\n";
cout<<"1. Insertar un caracter a una cola"<<endl;
cout<<"2. Mostrar todos los elementos de la cola"<<endl;
cout<<"3. Salir"<<endl;
cout<<"Opcion: ";
cin>>opc;
switch(opc){
case 1: cout<<"\nIngrese el caracter para agregar a la cola: ";
cin>>dato;
insertarCola(frente,fin,dato);
break;
case 2: cout<<"\nMostrando los elementos de la cola: ";
while(frente != NULL){
suprimirCola(frente,fin,dato);
if(frente != NULL){
cout<<dato<<" , ";
}
else{
cout<<dato<<".";
}
}
cout<<"\n";
system("pause");
break;
case 3: break;
}
system("cls");
}while(opc != 3);
}
//Función para insertar elementos en la cola
void insertarCola(Nodo *&frente,Nodo *&fin,char n){
Nodo *nuevo_nodo = new Nodo();
nuevo_nodo->dato = n;
nuevo_nodo->siguiente = NULL;
if(cola_vacia(frente)){
frente = nuevo_nodo;
}
else{
fin->siguiente = nuevo_nodo;
}
fin = nuevo_nodo;
}
//Función para determinar si la cola está vacia
bool cola_vacia(Nodo *frente){
return (frente == NULL)? true : false;
}
//Función para eliminar elementos de la cola
void suprimirCola(Nodo *&frente,Nodo *&fin,char &n){
n = frente->dato;
Nodo *aux = frente;
if(frente == fin){
frente = NULL;
fin = NULL;
}
else{
frente = frente->siguiente;
}
delete aux;
}
Estructura desde/para (“for”):
El bucle for es una estructura de control en programación en la que se puede indicar de antemano el número mínimo de iteraciones. Está disponible en casi todos los lenguajes de programación imperativos.
Elementos del bucle
Variable de control: prácticamente un mandato impuesto por el uso habitual es utilizar la letra i Iterador como variable de control, o bien sus sucesoras en caso de bucles anidados. El uso de esta letra críptica quizás a primera vista es sin embargo una excelente forma de aportar agilidad de lectura al código por su uso tan extensivo. Como raras veces los bucles anidados superan las tres dimensiones (por una sencilla cuestión de explosión exponencial), las letras i, j y k suelen ser las únicas relacionadas con este uso. En C se define en el primer parámetro de la instrucción junto con la inicialización (opcional).
Inicialización de la variable de control: en pseudolenguaje se pide explicitarlo (es la sección := ValorInicial), sin embargo, otros lenguajes más permisivos como C no lo requieren de forma obligatoria. De todos modos, la práctica de utilizar variables de control que no se inicializan en el bucle no es recomendada para la legibilidad del código. En C se define en el primer parámetro del bucle junto con la variable de control.
Condición de control: en pseudolenguaje se ve representado por el valor final que puede tomar la variable de control (la sección A ValorFinal). En C es el segundo parámetro y puede ser cualquier condición (ni siquiera es obligación que esté la variable de control, aunque una vez más, esto no se considera una buena práctica).
Incremento: en pseudolenguaje se toma por defecto el valor 1, aunque puede explicitarse por medio de la sentencia PASO = ValorPaso cualquier número entero (léase bien entero, o sea que técnicamente podemos decrementar). En C es el último parámetro.
Cuerpo: es lo que se hará en cada iteración, pueden ser una o más instrucciones. En pseudolenguaje pesa la restricción de no poder alterar el valor de la variable de control; esto no es requerido en C, pero no se considera una buena práctica.
#include<iostream>
#include<conio.h>
using namespace std;
int main(){
int matriz1[2][2] = {{1,2},{3,4}};
int matriz2[2][2];
//Copiando el contenido de la matriz1 hacia matriz2
for(int i=0;i<2;i++){
for(int j=0;j<2;j++){
matriz2[i][j]=matriz1[i][j];
}
}
//Mostrando matriz2
for(int i=0;i<2;i++){
for(int j=0;j<2;j++){
cout<<matriz2[i][j];
}
cout<<"\n";
}
getch();
return 0;
}
Sentencia de salto de interrumpir:
Sentencias de salto (programación). Permiten transferir el control del programa de forma incondicional. Existen cuatro de estas sentencias: break, continue, goto, return.
La sentencia break se usa para salir de forma incondicional de los bucles do, for y while, así como de las sentencias switch de multi-dicisión. Hay que tener en cuenta que en el caso de bucles anidados, break hace salir del bucle interior.
La sentencia continue se utiliza en los bucles for, while y do...while. En los primeros el control salta al final del bucle, con lo que el contador se incrementa y comienza otra comprobación. En los while, el control pasa inmediatamente a la condición de control.
#include<iostream>
#include<conio.h>
#include<string.h>
using namespace std;
int main(){
char frase[30];
int vocal_a=0,vocal_e=0,vocal_i=0,vocal_o=0,vocal_u=0;
cout<<"Digite una frase: ";
cin.getline(frase,30,'\n');
for(int i=0;i<30;i++){
switch(frase[i]){
case 'a': vocal_a++; break;
case 'e': vocal_e++; break;
case 'i': vocal_i++; break;
case 'o': vocal_o++; break;
case 'u': vocal_u++; break;
}
}
cout<<"\nContador de vocales"<<endl;
cout<<"Vocal a: "<<vocal_a<<endl;
cout<<"Vocal e: "<<vocal_e<<endl;
cout<<"Vocal i: "<<vocal_i<<endl;
cout<<"Vocal o: "<<vocal_o<<endl;
cout<<"Vocal u: "<<vocal_u<<endl;
getch();
return 0;
}
La sentencia goto permite transferir el control de ejecución a la etiqueta especificada por el identificador <etiqueta> (las etiquetas terminan siempre en dos puntos :). Recordar que la etiqueta debe estar en la misma función que el goto (el ámbito de las etiquetas se limita a la función en que son declaradas).
Comentarios
Publicar un comentario