Fundamento de Programación

viernes, 1 de mayo de 2020

Pasos para el blogg

Pasos para crear el blogg

1. Buscar la información.

2.Abrir una plantilla nueva del blogg.

3.Organizar la información buscada para el blogg.

4.Pasar la información a la plantilla del blogg.

5.Editar la información en la plantilla del blogg.

Acerca de mi

Soy Gerson Hernandez Hernandez nací en San Francisco el 10 de septiembre del 2001, vivo en Santo Domingo República Dominicana y tengo 18 años de edad.

Soy estudiante de ingeniera en software en la Universidad Adventista Dominicana (UNAD) siempre me apasionado la tecnología y todo sobre su ciencia queriendo desde mas joven ser un emprendedor y siempre he admirado esas grandes figuras de la tecnología y la ciencia, viendo sus logros me motivo a que algún día pueda yo también poder aportar algo al gran mundo de la tecnología y la ciencia con la ayuda de Dios y siempre poniendo lo en primer lugar.

Por Gerson Hernandez

Matricula: 2020-0121

Unidad 5

ARREGLOS

abril 28, 2020

Introducción a la estructura de datos:

Como ya sabemos, las computadoras fueron diseñadas o ideadas como una herramienta mediante la cual podemos realizar operaciones de cálculo complicadas en un lapso de mínimo tiempo. Pero la mayoría de las aplicaciones de este fantástico invento del hombre, son las de almacenamiento y acceso de grandes cantidades de información.

La información que se procesa en la computadora es un conjunto de datos, que pueden ser simples o estructurados. Los datos simples son aquellos que ocupan sólo una localidad de memoria, mientras que los estructurados son un conjunto de casillas de memoria a las cuales hacemos referencia mediante un identificador único.

Debido a que por lo general tenemos que tratar con conjuntos de datos y no con datos simples (enteros, reales, booleanos, etc.) que por sí solos no nos dicen nada, ni nos sirven de mucho, es necesario tratar con estructuras de datos adecuadas a cada necesidad.

Las estructuras de datos son una colección de datos cuya organización se caracteriza por las funciones de acceso que se usan para almacenar y acceder a elementos individuales de datos.

Una estructura de datos se caracteriza por lo siguiente:

· Pueden descomponerse en los elementos que la forman.

· La manera en que se colocan los elementos dentro de la estructura afectará la forma en que se realicen los accesos a cada elemento.

· La colocación de los elementos y la manera en que se accede a ellos puede ser encapsulada.

Ejemplo: Supongamos que nos enfrentamos a un problema como este: Una empresa que cuenta con 150 empleados, desea establecer una estadística sobre los salarios de sus empleados, y quiere saber cual es el salario promedio, y también cuantos de sus empleados gana entre $1250.00 y $2500.00.

Si tomamos la decisión de tratar este tipo de problemas con datos simples, pronto nos percataríamos del enorme desperdicio de tiempo, almacenamiento y velocidad. Es por eso que para situaciones de este tipo la mejor solución son los datos estructurados.

V. OBJETIVOS:

El objetivo por el cual fue el presente trabajo de Estructura de Datos, es el establecer un material de apoyo y consulta para ti que eres alumno de Ingeniería Informática y de Sistemas o de cualquier otra área afín en la cual se imparta la materia de Estructura de Datos. Una vez que hayas terminado de revisar detenidamente este material, serás capaz de establecer estructuras lógicas de datos que te permitan hacer un uso más eficiente del espacio de memoria, de minimizar los tiempos de acceso, así como de lograr formas más efectivas de inserción y eliminación de datos en estructuras de almacenamiento. Ahora que ya sabes en lo que te puede ayudar este tutorial, puedes empezar a hacer uso de él, consultando todas tu tareas y dudas que tengas acerca de la materia.

Acceder a cualquier elemento del arreglo sin tener que consultar a elementos anteriores o posteriores, esto mediante el uso de un índice para cada elemento del arreglo que nos da su posición relativa.

#include<iostream>

using namespace std;

int main(){

int n1,n2, suma = 0, resta = 0, multiplicacion=0,division=0;

cout<<"Digite un numero: "; cin>>n1;

cout<<"Digite otro numero: "; cin>>n2;

suma = n1 + n2;

resta = n1 - n2;

multiplicacion = n1 * n2;

division = n1 / n2;

cout<<"\nLa suma es: "<<suma<<endl;

cout<<"La resta es: "<<resta<<endl;

cout<<"La multiplicacion es: "<<multiplicacion<<endl;

cout<<"La division es: "<<division<<endl;

return 0;

}

Arreglos unidimensionales. Los vectores:

Hasta ahora hemos visto las tres estructuras de programación fundamentales: estructuras secuenciales, estructuras condicionales y estructuras repetitivas.

Al mismo tiempo hemos empleado variables de distinto tipo para el almacenamiento de datos (variables Integer, Double, String).

En esta sección veremos otros tipos de variables que permiten almacenar un conjunto de datos en una única variable.

Tipo de dato simple: Integer (Almacena un único entero)

Double (Almacena un único valor flotante)

String (Almacena un conjunto de caracteres)

Estructuras de datos: Array unidimensionales estáticos (Vector estáticos)

Un vector estático es una estructura de datos que permite almacenar un CONJUNTO de datos del mismo tipo.
Con un único nombre se define un vector y por medio de un subíndice hacemos referencia a cada elemento del mismo (componente).

Problema 1

Se desea guardar los sueldos de 5 operarios.
Según lo conocido deberíamos definir 5 variables si queremos tener en un cierto momento los 5 sueldos almacenados en memoria.

Empleando un vector solo se requiere definir un único nombre y accedemos a cada elemento por medio del subíndice.

La estructura de programación que más se adapta para cargar en forma completa las componentes de un vector es un for, ya que sabemos de antemano la cantidad de valores a cargar.

Es fundamental señalar qué elemento se está cargando en cada momento, esto se logra indicando el subíndice del vector: Sueldos[f], como sabemos la variable f es un contador del for que tomará valores entre 1 y 5.

Es un error si disponemos en la carga el nombre del vector únicamente sin indicar subíndice.

Se podría haber cargado con una estructura secuencial:

#include<iostream>

#include<math.h>

using namespace std;

int main(){

float a,b,c,resultado1 = 0,resultado2 = 0;

cout<<"Digite el valor de a: "; cin>>a;

cout<<"Digite el valor de b: "; cin>>b;

cout<<"Digite el valor de c: "; cin>>c;

resultado1 = (-b+sqrt(pow(b,2)-4*a*c))/(2*a);

resultado2 = (-b-sqrt(pow(b,2)-4*a*c))/(2*a);

cout<<"\nEl resultado 1 es: "<<resultado1<<endl;

cout<<"El resultado 2 es: "<<resultado2<<endl;

return 0;

}

Arreglos multidimensionales:

Arreglos multidimensionales pueden ser descritos como arreglos de arreglos. Por ejemplo, un arreglo bidimensional se puede imaginar como una tabla bidimensional de un tipo de dato concreto y uniforme.Los Arreglos multidimensionales no están limitados a dos índices (dos dimensiones). Pueden contener tantos índices como sea necesario, aunque es raro tener que representar más de 3 dimensiones. Solo considere la cantidad de memoria que un arreglo con muchos índices puede requerir. Por ejemplo: char century [100][365][24][60][60]; assigna un char para cada segundo contenido en un siglo, que es más de 3 mil millones de chars! Esto consumiría cerca de 3000 megabytes de memoria RAM si pudiéramos declararlo. Los arreglos multidimensionales no son más que una abstracción, ya que podemos obtener los mismos resultados con un simple arreglo poniendo un factor entre sus indices: int matriz [3][5]; es equivalente a int vector [15]; (3 * 5 = 15)

#include<iostream>#include<stdlib.h>#include<conio.h>using namespace std;
struct Nodo{ int dato; Nodo *siguiente; };
void insertarLista(Nodo *&,int);void mostrarLista(Nodo *);void calcularMayorMenor(Nodo *);
int main(){ Nodo *lista = NULL; int dato; char opcion; do{ cout<<"Digite un numero para agregarlo a lista: "; cin>>dato; insertarLista(lista,dato);    cout<<"\nDesea agregar un nuevo numero(s/n): "; cin>>opcion; }while(opcion == 's' || opcion == 'S'); cout<<"\nElementos de la lista: \n"; mostrarLista(lista); //mostramos la lista calcularMayorMenor(lista);   getch(); return 0;}
//Insertar elemento en la listavoid insertarLista(Nodo *&lista,int n){ Nodo *nuevo_nodo = new Nodo(); Nodo *aux; nuevo_nodo->dato = n; nuevo_nodo->siguiente = NULL; if(lista == NULL){//Si la lista esta vacia lista = nuevo_nodo;//agregamos el primer nodo } else{ aux = lista; while(aux->siguiente != NULL){//recorremos la lista hasta llegar al final   aux = aux->siguiente; } aux->siguiente = nuevo_nodo;//agregamos el nuevo nodo al final de la lista } cout<<"\tElemento "<<n<<" agregado a lista correctamente\n";}
//Mostrar todos los elementos de la listavoid mostrarLista(Nodo *lista){ Nodo *actual = new Nodo(); actual = lista; while(actual != NULL){ //mientras no sea final de la lista cout<<actual->dato<<" -> "; //mostramos el dato actual = actual->siguiente; //avanzamos a la siguiente posicion de la lista }}
//Calcular el menor y mayor elemento de la listavoid calcularMayorMenor(Nodo *lista){ int mayor=0,menor=99999; while(lista != NULL){//mientras no sea el final de la lista if((lista->dato)>mayor){//Comprobamos el numero mayor   mayor = lista->dato; } if((lista->dato)<menor){//Comprobamos el numero menor   menor = lista->dato; } lista = lista->siguiente;//Avanzamos en la lista } cout<<"\n\nEl mayor numero es: "<<mayor<<endl; cout<<"El menor numero es: "<<menor<<endl; }

ARREGLOS Y ESTRUCTURAS

Arreglo (array)

Es una colección o conjunto de variables relacionadas entre sí, por el hecho de que todas tienen el mismo nombre y son del mismo tipo.Un arreglo es una variable capaz de guardar uno o más valores del mismo tipo. Un arreglo consta de posiciones de memoria contiguas, para referirse a una posición en particular o elemento dentro de un arreglo especificamos el nombre del arreglo y el número de posición del elemento particular dentro del mismo.                    - Unidimensionales (vectores)
Arreglos     - Bidimensionales (matrices)
                    - Multidimensionales

Arreglos unidimensionales
Son esencialmente listas de información de un solo tipo, es decir, de una sola dimensión. Por ejemplo, tenemos el siguiente arreglo de enteros llamado a.

Arreglo tridimencional

CADENAS

El uso más corriente de un arreglo unidimensional es crear cadenas de caracteres.En C/C++, una cadena es un arreglo de caracteres, que termina con un caracter nulo (‘\0’).
Por esta razón, se debe declarar arreglos de caracteres con un caracter más que la cadena más larga que vaya a guardar.Se tiene acceso a una cadena mediante un apuntador al primer caracter de la cadena.Una cadena puede ser asignada en una declaración, ya sea un arreglo de caracteres o una variable de tipo char.
char cadena [11];                //cadena de 10 caracteres            char color[ ] = “blue”;          // 5 elementos            char color [ ] = [“’b’, ‘l’, ‘u’, ‘e’, ‘\0’};
La mejor manera de introducir una cadena desde el teclado es usando la función de biblioteca gets ( ).
El formato general es:  gets (nombre_arreglo);Funciones de cadena de la biblioteca de C/C++El archivo cabecera <string.h> contiene un gran número de funciones de manipulación de cadena.
Las más comunes son:Ø  strcpy ( )Ø  strcat ( )Ø  strcmp ( )Ø  strlen ( ) Función strcpyCopia los contenidos de la cadena desde  a la cadena a.Función strcatLa función strcat ( ) añade s2 al final de s1; s2 no se altera. Ambas cadenas terminan con un nulo y el resultado temina en nulo.Función strcmpLa función strcmp ( ) compara dos cadenas y devuelve 0 (cero) si son iguales.
Si s1 es lexicográficamente mayor que s2, entonces la función devuelve un número positivo; su s1 es menor que s2, la función devuelve un número negativo.
Función strlenLa función strlen ( ) devuelve la longitud de la cadena s.
Arreglos bidimensionalesLos arreglos multidimensionales constan de dos o más dimensiones. La forma más común para utilizar los arreglos multidimensionales son los arreglos bidimensionales (matrices)  que representan tablas de valores, consistiendo de información arreglada en renglones (filas) y columnas.
El formato general para la declaración de un arreglo bidimensional:tipo nombre_arreglo [m][n];tipo nombre_arreglo[tam];tipo nombre_arreglo[tam];tipo declara el tipo de datos de cada elemento del arreglo.m número de renglones (filas) del arreglo.n número de columnas del arreglo.
Para identificar un elemento particular de la tabla, se especifican 2 subíndices:-          el primero identifica el renglón del elemento.-          el segundo identifica la columna del elemento.Por ejemplo, para declarar un arreglo bidimensional (matriz) de 3x4 de tipo flotante:float matriz [3] [4];Otras declaraciones:int num [3] [2];double a [100] [40];int m [F] [C];              // donde F y C se declaran como constantes simbólicasfloat f [10] [5];Estructuras (struct)En muchos casos, los programas necesitarán agrupar información relacionada que puede no ser del mismo tipo.
Por ejemplo, supongamos que el programa trabaja con registros de empleado.
Se debe seguir la pista del nombre, la edad, el salario, la dirección, el número de empleado, el número de puesto, etc.
Para almacenar esta información el programa necesitaría variables de tipo char, int, float, así como cadenas de caracteres. Cuando es necesario guardar información relacionada de tipo diferente, el programa puede utilizar una estructura.
Las estructuras son colecciones de variables relacionadas que se referencian bajo un mismo nombre.struct (palabra reservada para definir una estructura) dice al compilador que se va a definir una estructura.dire (rótulo de la estructura) da nombre a la definición de la estructura.
Las variables declaradas dentro de las llaves de la definición de la estructura son los miembros de la estructura. Los miembros de la estructura deben tener nombres únicos, pero dos estructuras diferentes pueden contener miembros con el mismo nombre sin entrar en conflicto.
Cada definición de estructura debe terminar con punto y coma (;).Por lo tanto, el formato general de una definición de estructura es:struct nombre_tipo_de_estructura {            tipo nombre_elemento1;            tipo nombre_elemento2;      miembros                        ...            tipo nombre_elemento_n;} variables_estructura;struct define un determinado tipo de estructura (nombre_tipo_de_estructura) y declara las variables_estructura del mismo tipo.
Si sólo se necesita una variable estructurada, no se necesita incluir el nombre de la estructura.Las únicas operaciones válidas que pueden ejecutarse sobre estructuras son: asignar variables de estructura a variables de estructura del mismo tipo, tomando la dirección (&) de una variable de estructura, obteniendo acceso a los miembros de una variable de estructura, y utilizando el operador sizeof,  a fin de determinar el tamaño de la variable de estructura.
Operador sizeofEl operador unario especial sizeof  determina el tamaño de un arreglo en bytes (o de cualquier otro tipo de datos) durante la compilación de un programa.   Cuando se aplica al nombre de un arreglo, el operador sizeof regresa como un entero el número total del bytes del arreglo. Para esto, se utiliza de la siguiente manera:                        sizeof (nombre_arreglo)El operador sizeof  puede ser aplicado a cualquier nombre de variable, tipo o constante.
Al se aplicado aun nombre de variable (que no sea un nombre de arreglo), o a una constante, será regresado el número de bytes utilizados para almacenar el tipo específico de variable o de constante.
UnionesConforme los programas se vuelven más complejos, habrá ocasiones en que necesiten diferentes formas de ver una parte de la información, además habrá otras veces que se tenga la necesidad de trabajar con dos o más valores, pero solamente utilizar uno de los valores en un momento dado.
En tales casos, los programas pueden utilizar las uniones para guardar los datos. Una unión es un tipo de datos derivado, como lo es una estructura, cuyos miembros comparten el mismo espacio de almacenamiento.
Para distintas situaciones en un programa, algunas variables pudieran no ser de importancia, pero otras variables lo son, por lo que una unión comparte el espacio, en vez de desperdiciar el almacenamiento en variables que no están siendo utilizadas. Los miembros de una unión pueden ser de cualquier tipo.
El número de bytes utilizados para almacenar una unión, deben ser por lo menos suficiente para contener el miembro más grande.   En la mayor parte de los casos, las uniones contienen dos o más tipos de datos.
Únicamente un miembro y, por lot anto, únicamente un tipo de datos, puede ser referenciado en un momento dado. Es responsabilidad del programador asegurarse que en una unión los datos están referenciados con el tipo de dato apropiado.Una unión se declara con la palabra reservada union en el mismo formato que una estructura:union nombre_tipo_union {      tipo elemento_1;     tipo elemento_2;   . . .      tipo elemento_n;   } variables_union;EnumeracionesUna enumeración es un conjunto de constantes enteras representadas por identificadores. Estas constantes de enumeración  son constantes simbólicas cuyos valores pueden ser definidos automáticamente.
La declaración de una enumeración se realiza con la palabra reservada enum:enum nombre_enum {lista_enum} lista_variables;Arreglos bidimensionalesSon arreglos de dos dimensiones, son llamados tablas o matrices.  Se accesa a los elementos de un arreglo bidimensional por medio de dos índices, b [i] [j].

Arreglos multidimensionales
Son arreglos de 3 dimensiones o más, se accesa a los elementos por medio de 3
índices o más, c [i] [j] [k]

Arreglos unidimensionales

Unidad 3-4

CONTROL DE FLUJO (ESTRUCTURAS DE REPETICIÓN)

abril 28, 2020

Escrituras repetitivas

Las estructuras repetitivas son aquellas que sirven
para 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;
}

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;

}

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.¹

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;

}

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.

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).