1. DOCENTE : NIELS HENRIK ARANA CUEVAS
ALUMO: ELIU OSSEAS PUC PUC
TERCER SEMESTRE GRUPO B
AULA J-4

2. Contenido
Introducción programa 1: imprime línea, la diagonal y la diagonal invertida.............................. 3
Conclusión: ........................................................................................................................... 5
ARREGLOS BIDIMENSIONALES ................................................................................................ 5
PROGRAMA 1: ....................................................................................................................... 5
CONCLUSION:.......................................................................................................................10
DATOS ABSTRACTOS .............................................................................................................11
LEE DOS NOMBRES Y DOS EDADES Y SUMA LAS EDADES .........................................................11
INTRODUCCION:.......................................................................................................................11
PROGRAMA 2: MUESTRA 3 NOMBRES, LA EDAD DE LOS 3, MAYOR Y MENOR EDAD DE LOS 3 Y
EL PROMEDIO DE LOS 3.........................................................................................................13
INTRODUCCION:.......................................................................................................................13
CONCLUSION:.......................................................................................................................16
FUNCIONES ..........................................................................................................................16
PROGRAMA 1: PIDE DOS NUMEROS Y REALIZA LA SUMA ........................................................16
CONCLUSION:.......................................................................................................................18
PROGRAMA 2: IMPRIME DOS NÚMEROS, LA SUMA, LA RESTA, LA DIVISIÓN Y LA RESTA DE
AMBOS. ...............................................................................................................................18
CONCLUSION:.......................................................................................................................21
CONCLUSION GENERAL .........................................................................................................22

3. Introducción programa 1: imprime línea, la diagonal y la diagonal invertida
En este primer programa nos va a permitir imprimir valores que están en una
matriz, en la cual primeramente se imprimirán los valores que están en su fila
principal seguidamente de su diagonal principal y por ultimo su diagonal invertida.
Primeramente el programa dice que va a ser una matriz de tres por tres y que va a
contener valores de tipo entero contenidos en u arreglo como se muestra en el
programa. Seguidamente tenemos un ciclo for en la cual le damos una condición
en donde le va a dar valores a i que se estarán igualando a cero que
seguidamente se imprimirán al final. Seguidamente con la condición cumplida el
programa imprimirá los valores que están en la condición mencionada. De igual
manera mas adelante tenemos lo que es imprimir la diagonal invertida el cual de
declaran las variables y con el for le damos la condición y al final y le asignamos
las variables que utilizaremos y seguidamente se imprime los valores de la
diagonal invertida.
#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop
*/
int main(int argc, char** argv) {
int a[3][3],dip,dinv,liu;
for(int i=0;i<=2;i++){
for(int j=0;j<=2;j++){
cout<<"ingrese elementos: ";
cin>>a[i][j];
}
}cout<<"La Matriz es:n";
// Imprimiendo el arreglo en formato matricial
for(int i=0;i<3;i++){
for(int j=0; j<=2;j++){
cout<<a[i][j];
}

4. }
cout<<"n";
cout<<"La diagonal principal es: n ";
for(int i=0;i<=2;i++){
for(int j=0;j<=2;j++){
if(i==j){
dip=a[i][j];
cout<<dip;
}
}
}
cout<<"n";
cout<<"La diagonal invertida es: n ";
for(int i=0;i<=2;i++){
for(int j=0;j<=2;j++){
if((i+j)==2){
dinv=a[i][j];
cout<<dinv;
}
}
}
cout<<"n";
cout<<"La linea 1 es: n ";
for(int i=0;i<=2;i++){
liu=a[1][i];

5. cout<<liu;
}
return 0;
Conclusión:
En este primer programa aprendimos el uso de los arreglos en el cual
sabemos que un arreglo es un conjunto de valores en el cual podemos
expresar de diferentes formas una de ellas es en una matriz. En este
programa que analizamos vimos el uso de los arreglos ya que le
decíamos al programa que estaremos trabajando con una matriz de 3
x 3 declaramos las variables a utilizar le poníamos la condición, ya sea
que queramos imprimir una fila, una columna, la diagonal principal, o
la diagonal invertida. En este caso el programa visto imprime la
diagonal principal, y la diagonal invertida en donde en este caso cando
le asignamos las variables i y j que representan las filas y las
columnas, el programa imprimirá los valores de la matriz cuando i y j
sean iguales o en donde se intersecten esos valores será lo que el
programa imprimirá.
Introducción:
ARREGLOS BIDIMENSIONALES
PROGRAMA 1:
Primero se inicializan las variables que se deban utilizar pero más importante el
arreglo, que debe tener la sintaxis tipo nombre [ ] [ ]; luego se pide al
usuario que ingrese los valores del mismo arreglo se promedian las calificaciones
del alumno así como de las unidades y se guardan en arreglo unidimensionales. Se
realiza las comparaciones entre el arreglo unidimensional de unidades para
determinar cuál es el mayor y se imprime en pantalla, posterior a ello se hace las
comparaciones en el vector de alumnos para determinar al alumno de mejor
calificación y al peor. Por último se vuelve a imprimir los datos correspondientes.
#include <iostream>
using namespace std;

6. /* run this program using the console pauser or add your own
getch, system("pause") or input loop */
int main(int argc, char** argv) {
float ca[2][5];
int f, c, SU=0, SA=0, MU=0, MA=0, MeA=0;
float PAL[2];
float PRU[5];
//Leer calificaciones
for(f=0;f<2;f++){
for(c=0;c<5;c++){
cout<<"Ingrese la calificacion del alumno
["<<f<<"] en la unidad ["<<c<<"]: t";
cin>> ca[f][c];
}
}
cout<<"n";
//Promedio de alumno
for(f=0;f<2;f++){
for(c=0;c<5;c++){
SA=SA + ca[f][c];
}

7. PAL[f]=SA/5;
SA=0;
}
//Promedio de unidades
for (c=0; c<5; c++){
for (f=0; f<2; f++){
SU = SU + ca[f][c];
}
PRU[c] = SU/2;
SU = 0;
}
//Unidad mayor
for (f=0; f<5; f++){
if(PRU[MU] < PRU[f]){
MU = f;
}
}
cout << "La unidad mayor es: " << MU << "n"<< endl;
//mayor promedio alumno
for (f=0; f<2; f++){
if(PAL[MA] < PAL[f]){
MA = f;
}

8. }
//imprimir calificaciones del alumno mayor
cout << "Calificaciones del mejor alumno son: n";
for (f=0; f < 5; f++){
cout<<ca[MA][f]<<"t"<<"n";
}
cout<<"n";
//menor promedio alumno
for (f=0; f<2; f++){
if(PAL[MeA] > PAL[f]){
MeA = f;
}
}
//imprimir calificaciones del alumno con menor promedio
cout << "Calificaciones del peor alumno es: n";
for (f=0; f < 5; f++){
cout<< ca[MeA][f] <<"t" << "n";
}
return 0;
}
#include <iostream>
using namespace std;

9. /* run this program using the console pauser or add your own getch, system("pause") or
input loop */
int main() {
float alu[5][3], cal, prom[5], pu[3], su;
int i, j;
int mayu=0;
int maypro = 0;
int menpro = 0;
for (i=0; i<5; i++){
for (j=0; j<3; j++){
cout << "Introduce la calificacion del alumno"<<endl;
cin >> alu[i][j];
}
}
for (i=0; i<5; i++){
for (j=0; j<3; j++){
su = su + alu[i][j];
}
prom[i] = su/3;
su = 0;
}
for (j=0; j<3; j++){
for (i=0; i<5; i++){
su = su + alu[i][j];
}
pu[j] = su/5;
su = 0;
}
for (i=0; i<3; i++){
if(pu[mayu] < pu[i]){

10. mayu = i;
}
}
cout << "El mejor aprovechamiento es en la unidad: " << mayu << endl;
for (i=0; i<5; i++){
if(prom[maypro] < prom[i]){
maypro = i;
}
}
for (i=0; i < 3; i++)
{cout << "Calificaciones del mejor alumno son: " << alu[maypro][i] << endl;
}
for (i=0; i<5; i++){
if(prom[menpro] > prom[i]){
menpro = i;
}
}
for (i=0; i < 3; i++){
cout << "Calificaciones del peor alumno es: " << alu[menpro][i] << endl;
}
return 0;
}
CONCLUSION:
En este programa se requiere un análisis un tanto más profundo del tema requiere
un mayor entendimiento de su realización para que nuestro programa funcione y
no nos genere problemas y se ejecute correctamente ya que si no se sabe cómo
realizar las iteraciones entre los arreglos bidimensionales y unidimensionales se nos
va a ser más complicado su entendimiento. Uno de los puntos que en que me ha
resultado un tanto mas inospito es del porque se inicia la cuenta con el 0 y no con
el uno para un mayor entendimiento, . Y bueno como en un principio se nos había

11. pedido un valor o un arreglo de una gran escala o un gran número de datos pues
solamente hay que verificar si funciona con un arreglo no tan grande.
DATOS ABSTRACTOS
LEE DOS NOMBRES Y DOS EDADES Y SUMA LAS EDADES
INTRODUCCION:
El funcionamiento de este programa va de esta manera, primero se declaran un tipo
de dato abstracto con el nombre alumno que sus tipos de datos han de ser de tipo
cadena y el otro de tipo entero. Una vez hecho esto dentro de la función main que
es la principal, se declara las variables a utilizar en este caso a1 y a2. Luego se
procede a pedir datos al usuario de tipo cadena para el nombre y de tipo entero para
la edad, después las siguientes líneas de código nos indican que esos tipos de datos
enteros de edades se deben de sumar y se deben de mostrar en pantalla que es lo
que se está logrando al final. Cabe mencionar que para el uso de esos datos
abstractos se pone el nombre de la variable ya creada en el main seguida de un
punto y el tipo de dato abstracto que se encuentre en el struct.
#include <iostream>
using namespace std;
struct alumno {
string nombre;
int edad;
};
int main(int argc, char** argv) {
alumno a1, a2;

12. //primer alumno
cout<<"Teclea el nombre del primer alumno:";
cin>>a1.nombre;
cout<<"Teclea la edad del primer alumno:";
cin>>a1.edad;
cout<<"n";
//segundo alumno
cout<<"Teclea el nombre del segundo alumno:";
cin>>a2.nombre;
cout<<"Teclea la edad del segundo alumno:";
cin>>a2.edad;
cout<<"n";
//suma de las edades
cout<<"L suma de las dos edades es:"<<a1.edad+a2.edad<<endl;
return 0;
}
Se debe uti lizar el siguiente formato para la creación de un tipo de dato abstracto:
struct alumno {
string nombre;

13. int edad;
};
Si observamos al final de la segunda llave se pone un punto y coma cosa que no es
común si se usase un for.
Cuando usemos o convoquemos el dato abstracto lo debemos realizar con el
siguiente formato:
Variable.nombre del dato abstracto creado.
Los datos abstractos son muy útiles cuando se habla de datos en los cuales se
requieran diversos campos, como por ejemplo, el campo nombre, edad, genero,
etc.
PROGRAMA 2: MUESTRA 3 NOMBRES, LA EDAD DE LOS 3, MAYOR Y MENOR EDAD DE
LOS 3 Y EL PROMEDIO DE LOS 3
INTRODUCCION:
Los datos abstractos de manera práctica o en este código se refiere a un dato
hecho por el programador y como su nombre lo indica puede contener varios tipos
de datos para ser abstracto. En este programa se muestra en el código: "struct
alumno {" la forma en la que esta ha de declararse fuera del método principal
main. Ahí mismo dentro del tipo de dato abstracto se colocan los tipos de datos o
más bien las variables que hemos de ocupar. En el método principal main se
declaran las variables que sean fáciles de identificar al momento de convocar o
usar el dato abstracto. En las siguientes líneas de cogido se solicita el nombre y la
edad del primer alumno, y como ya hemos definido un dato abstracto con varios
datos simplemente colocamos después de la variable en el método main un
punto: a1.nombre, con eso hemos de usar la variable abstracta definida en el inicio
del programa. Y bueno una vez solicitados todos los datos al usuario se procede a
imprimirlos, esto al final de cuentas nos permite una mejor organización d nuestros
datos. Una vez solicitados nuestros datos al usuario en este programa se utilizó
las condicionales if(){}else{}. Para la comparación del que tiene la mayor edad y
del que tiene la menor edad y una suma muy simple para poder sacar el promedio,
ahora sí solamente ubicamos la variable para imprimirlas en pantalla.
#include <iostream>
using namespace std;

14. struct alumno {
string nombre;
int edad;
};
//variable promedio
float prom;
int main(int argc, char** argv) {
alumno a1, a2, a3;
//primer alumno
cout<<"Teclea el nombre del primer alumno:";
cin>>a1.nombre;
cout<<"Teclea la edad del primer alumno:";
cin>>a1.edad;
cout<<"n";
//segundo alumno
cout<<"Teclea el nombre del segundo alumno:";
cin>>a2.nombre;
cout<<"Teclea la edad del segundo alumno:";
cin>>a2.edad;
cout<<"n";
//tercer alumno
cout<<"Teclea el nombre del tercer alumno:";
cin>>a3.nombre;
cout<<"Teclea la edad del tercer alumno:";
cin>>a3.edad;
cout<<"n";
//mayor edad
if((a1.edad>a2.edad) && a1.edad>a3.edad){
cout<<"La edad mayor es:"<<a1.edad<<endl;

15. }
else{
if((a2.edad>a1.edad) && a2.edad>a3.edad){
cout<<"La edad mayor es:"<<a2.edad<<endl;
}
else
{
if((a3.edad>a2.edad) && a3.edad>a1.edad){
cout<<"La edad mayor
es:"<<a3.edad<<endl;
}
//la edad del menor
if((a1.edad<a2.edad) && a1.edad<a3.edad){
cout<<"La edad menor es:"<<a1.edad<<endl;
}
else{
if((a2.edad<a1.edad) && a2.edad<a3.edad){
cout<<"La edad menor es:"<<a2.edad<<endl;
}
else
{
if((a3.edad<a2.edad) && a3.edad<a1.edad){
cout<<"La edad menor
es:"<<a3.edad<<endl;
}
}
return 0;
}
}
}
//El promedio de las edades
prom=(a1.edad+a2.edad+a3.edad)/3;
cout<<"El promedio de las 3 edades es:"<<prom<<endl;
}

16. CONCLUSION:
Los datos abstractos se crean por el usuario para su mejor entendimiento
No se debe confundir o usar variables con el mismo nombre que se encuentran en
el dato abstracto y en el método main.
Lo aprendido en este apartado fue de la forma en el cual se comienza a crear un
dato abstracto utilizando la palabra reservada de java struct, cosa en la
programación orientada a objetos es muy diferente o un tanto mas complejo que
en este lenguaje de programación. Otros aprendizajes significativo fue la forma de
utilizar tal fato abstracto usando un punto para su llamado y posterior utilización.
es conveniente no usar mismas variables para su utilización en el método main.
FUNCIONES
PROGRAMA 1: PIDE DOS NUMEROS Y REALIZA LA SUMA
INTRODUCCION:
Este pequeño programa realiza a base de funciones la lectura de dos números, la
suma de los mismos y la impresión de los resultados. Pero como funciona, es muy
bueno, primero iniciamos las funciones con el nombre que deseemos ponerle.
Creamos nuestras variables globales o locales, en el main se convocan las
funciones que vamos a crear, se crean las funciones leer, sumar e imprimir.
Bueno en cada función como su nombre lo indica realiza una acción que al momento
de ser llamados en el main se han de ejecutar siempre y cuando sean llamados
claro. Y conclusión tenemos que lo que hizo este programa fue nada mas que
sumar dos números, lo cual se podría realizar sin funciones pero la importancia de
este es el orden.

17. #include <iostream>
using namespace std;
//inicializacion de funciones
void leer();
void sumar();
void imprimir();
//varibles globales
int suma, n1, n2;
//llamado de funciones
int main(int argc, char** argv) {
leer();
sumar();
imprimir();
return 0;
}
//funcion lectura de datos
void leer()
{
cout<<"Ingrese un numero:";
cin>>n1;
cout<<"Ingrese otro numero:";
cin>>n2;
}
//funcion suma de datos
void sumar()
{
suma=n1+n2;
}

18. //funcion salida de datos
void imprimir()
{
cout<<"La suma de los dos numeros es:"<<suma;
}
CONCLUSION:
Bueno hasta ahora sabemos que las funciones nos permiten organizar, entender y
corregir mejor los programas más extensos con la cual lidiemos. Además de que no
regresan un valor, estas funciones también podrían regresar un valor cuando se
hable de parámetros en ellos. Cuando una función es invocada se le pasa el control
a la misma, una vez que esta finalizó con su tarea el control es devuelto al punto
desde el cual la función fue llamada.
PROGRAMA 2: IMPRIME DOS NÚMEROS, LA SUMA, LA RESTA, LA DIVISIÓN Y LA
RESTA DE AMBOS.
INTRODUCCION:
En este caso en particular el programa no usa parámetros para simplemente se
usa un void para indicar que no devuelve ningún valor. Primeramente se inicializaron
las funciones con el formato void seguido de un paréntesis y punto y coma de la
categoría o función que debe realizar. Como las variables se han de ocupar en todas
las funciones entonces se declaran arriba del método o función principal main y en

19. el caso de que no se usen para todas las funciones pues en si se definen en donde
se deba utilizar. Siguiendo se crean las funciones inicializadas ahora después de
los dos paréntesis se agrega un par de corchetes cerrados que es donde la cual el
código o instrucción que realiza se almacenará ahí mismo. Una vez creado las
funciones, dentro del método principal se convocan o llaman a las funciones
anteriores para realzar su función y dependiendo del código que deba aparecer en
pantalla realizarán lo que se llama su acción.
#include <iostream>
#include <conio.h>
using namespace std;
//lee todas las funciones
void lee (void);
void sum (void);
void res(void);
void multi(void);
void div(void);
void imprimir(void);
//variables globales
int n1, n2, s,r,m;
float d;
//metodo principal
int main(int argc, char** argv) {
lee ();
sum ();

20. res ();
multi ();
div();
imprimir ();
return 0;
}
//para leer
void lee (){
cout<<"Ingrese en numero 1:";
cin>>n1;
cout<<"Ingrese en numero 2:";
cin>>n2;
}
//para sumar
void sum (){
s=n1+n2;
}
//para restar
void res(){
r=n1-n2;
}
//para multiplicar
void multi(){
m=n1*n2;
}
//para dividir
void div(){
d=n1/n2;
}

21. //para imprimir
void imprimir(){
cout<<"La suma de los dos numeros es: "<<s<<endl;
cout<<"La resta de los dos numeros es: "<<r<<endl;
cout<<"La multiplcacion de los dos numeros es: "<<m<<endl;
cout<<"La division de los dos numeros es: "<<d<<endl;
CONCLUSION:
Se debiera seguir el orden de inicialización de funciones, creación de funciones y
llamado de funciones.
Se recomienda dominar el uso de funciones con parámetros.
Se debe entender que función hace honor a su nombre.
Comprender que las funciones son útiles cuando el programa es muy extenso y se
debe utilizar una misma instrucción para cierta actividad.
Se optimiza la búsqueda de errores y ahorro mas de tiempo en corregir el
programa
Las funciones pueden utilizarse con todos los tipos de datos en c++
No se puede usar funciones con el mismo nombre.

22. CONCLUSION GENERAL
En esta unidad 1 analizamos los arreglos unidimensionales y bidimensionales es
muy importante entender muy bien todo lo ha aprendido hasta ahora porque mas
adelante nos servira en un momento de la programación o más bien será con lo que
más hemos de trabajar. aprendimos como se declaran los arreglos
unidimensionales y bidimensionales las cuales tienen una di ferencia de ser un
vector y una matriz respectivamente. Y un dato que es de vital importancia es que
siempre vamos a utilizar un for para las filas y otro for para las columnas, o de hecho
para el análisis de dichos arreglos siempre se van a usar siempre basándonos en
las coordenadas. Otro punto muy importante es bueno mencionar y no mencione
en las conclusiones anteriores en el código Using namespace std; que nos ha de
servir para el ingreso y salida de datos de no ser así siempre va a anteceder un
std::cout o un std::cin cuando queramos introducir datos lo cual nos hace perder un
poco de tiempo. despues realizamos un énfasis en los tipos de datos abstractos que
si bien queda comprendido que es el programador quien los crea siempre utilizando
los tipos de datos del lenguaje e iniciando con ello con un struct{} y adentro de los
corchetes van los tipos de datos, por ultimo vimos las funciones que son similares
a los datos abstractos, con la diferencia de que en las funciones se realizan como
su nombre lo indica funciones u operaciones que al final son convocados en el
método principal main para ser utilizados.