CUADERNILLO DE PROGRAMACIÓN II by Gusttavo Masaquiza

TEMA: CUADERNILLO DE TRABAJOS Y EJERCICIOS EN C++

TRBAJO DE: PROGRAMACIÓN II

NOMBRE: JOSÉ GUSTAVO MASAQUIZA

3º INFORMÁTICA Y COMPUTACIÓN 2

TABLA DE CONTENIDOS PÁG MATRICES EN C++ DEFINICIÓN DE MATRICES……………………………………………………………………………………...4 ELEMENTOS DE UNA MATRIZ………………………………………………………………………………….4 TIPOS DE MATRICES………………………………………………………………………………………………..4 ESTRUCTURA DE DATOS………………………………………………………………………………………….4 VECTORES……………………………………………………………………………………………………………….5 ARRAYS…………………………………………………………………………………………………………………..6 CLASIFICACIÓN DE ARRAYS……………………………………………………………………………………..6 ENUNCIADO_1………………………………………………………………………………………………………..6 ENUNCIADO_2……………………………………………………………………………………………………….10 ENUNCIADO_3……………………………………………………………………………………………………….14 ENUNCIADO_4……………………………………………………………………………………………………….26 ENUNCIADO_5……………………………………………………………………………………………………….30 ENUNCIADO_6……………………………………………………………………………………………………….37 BIBLIOGRAFÍA………………………………………………………………………………………………………..42

MATRICES EN C++ 1. DEFINICIÓN DE MATRICES Una matriz es un conjunto ordenado en una estructura de filas y columnas. Los elementos de este conjunto pueden ser objetos matemáticos de muy variados tipos, aunque de forma particular, trabajan exclusivamente con matrices formadas por números reales. Normalmente las matrices son designadas por letras minúsculas. ELEMENTOS DE UNA MATRIZ Se identifican por la fila y la columna que ocupan.

TIPOS DE MATRICES  



Unidimensionales, también llamado vector o fila, compuesto de un número determinado de elementos. Bidimensionales, también llamado tabla o matriz, al igual que los vectores deben ser ordinales se declaran al igual manera que los que los arrays de una dimensión. Multidimensionales, son estructuras de datos que almacenan los valores en más de una dimensión.

2. ESTRUCTURA DE DATOS Una estructura de Datos es una colección de datos que pueden ser caracterizados por su organización y las operaciones que se definen en ella. Los tipos de datos más frecuentes utilizados en los diferentes lenguajes de programación son:

Las estructuras de datos estáticas: Son aquellas en las que el tamaño ocupado en memoria se define antes de que el programa se ejecute y no puede modificarse dicho tamaño durante la ejecución del programa. Estas estructuras están implementadas en casi todos los lenguajes. Su principal característica es que ocupan solo una casilla de memoria, por lo tanto una variable simple hace referencia a un único valor a la vez, dentro de este grupo de datos se encuentra: enteros, reales, caracteres, boléanos, enumerados y sub rangos (los últimos no existen en algunos lenguajes de programación) Las estructuras de datos dinámicas: No tienen las limitaciones o restricciones en el tamaño de memoria ocupada que son propias de las estructuras estáticas. Mediante el uso de un tipo de datos especifico, denominado puntero, es posible construir estructuras de datos dinámicas que no son soportadas por la mayoría de los lenguajes, pero que en aquellos que si tienen estas características ofrecen soluciones eficaces y efectivas en la solución de problemas complejos. Se caracteriza por el hecho de que con un nombre se hace referencia a un grupo de casillas de memoria. Es decir un dato estructurado tiene varios componentes. 3. VECTORES Desde el punto de vista del programa, un vector es una zona de almacenamiento contiguo, que contiene una serie de elementos del mismo tipo, los elementos de la matriz. Desde el punto de vista lógico podemos considerarlas como un conjunto de elementos ordenados en fila. Así pues, en principio todas las matrices son de una dimensión, la dimensión principal, pero veremos que los elementos de esta fila pueden ser a su vez matrices (un proceso que puede ser recursivo), lo que nos permite hablar de la existencia de matrices multi-dimensionales. PARA QUE SIRVE En los vectores son una forma de almacenar datos que permiten contener una serie de valores del mismo tipo, cada uno de los valores contenidos tiene una posición asociada que se usará para accederlos. Está posición o índice será siempre un número entero positivo.

4. ARRAYS En programación, un arrays es un conjunto o agrupación de variables de mismo tipo cuyo acceso se realiza por índices, los vectores o arrays de dos o más dimensiones se denomina matrices que pueden tener tantas dimensiones como uno lo desee, pero si una variable tiene más de dos dimensiones no cumple con las características matemáticas de una matriz numérica. Qué es un arrays, es un medio de guardar un conjunto de objetos de la misma clase. Se accede a cada elemento individual del arrays mediante un número entero denominado índice. Utilidad de un arrays, un arrays sirve para visualizar como una colección de cajas que representan variables de un mismo tipo de datos. CLASIFICACIÓN DE ARRAYS:



Arrays unidimensionales, también llamado vector o fila, compuesto de un número determinado de elementos.



Arrays bidimensionales, también llamado tabla o matriz, al igual que los vectores deben ser ordinales se declaran al igual manera que los que los arrays de una dimensión.



Arrays multidimensionales, son estructuras de datos que almacenan los valores en más de una dimensión.

ENUNCIADO DE LOS EJERCICIOS:

ENUNCIADO TAREA1._Diseñar un programa en C que permita ingresar datos enteros en una matriz entre 8 y 58, presente el resultado de la matriz solo de sus diagonales principales y secundarias. ANÁLISIS    

Ingresar datos enteros en una matriz. Datos entre 8 y 58. Presentar el resultado de la matriz. Presentar matriz solo de su diagonal principal y secundaria.

DESARROLLO            

Ingreso librerías en C++. En entero (int) ingreso matrices y otros variables para su desarrollo. Ingreso una variable que me permita ingresar un límite. Ingreso una variable que me permita ingresar la matriz entrante. Ingreso for para que de vueltas hasta el límite ingresado. Ingreso do-while para que me permita ingresar datos asignados entre 8 y 58. Divido la variable de ingreso, Si tiene un %0, es entero, y me permite seguir ingresando datos. Ingreso Printf para imprimir datos enteros ingresados. Ingreso variable aux la cuál valido como un límite. Posiciono filas y columnas. Visualizo con printf los valores de la diagonal principal y secundaria.

#include<conio.h> #include<stdio.h> #include<stdlib.h> void main() { int i,j,matriz[10][10],col,fil,entero,num,lim,m,n,matriz1[10][10],aux,aux1,op,col1,fil 1; do { clrscr(); for(i=1;i<=80;i++) { gotoxy(i,1);printf("¸"); gotoxy(i,24);printf("¸"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("¸"); gotoxy(80,i);printf("¸"); } textcolor(3); gotoxy(26,2);cprintf("MATRIZ ENTERO ENTRE 8 Y 58"); gotoxy(5,5);printf("Ingresar un limite: ");scanf("%d",&lim); textcolor(10);

gotoxy(5,8);cprintf("M.ENTRANTE"); textcolor(20); gotoxy(30,8);cprintf("M.SALIENTE"); textcolor(31); gotoxy(55,8);cprintf("D.PRINCIPAL - SECUNDARIO"); col=5,fil=11; for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++) { do { do { gotoxy(col,fil);printf(" "); gotoxy(col,fil);scanf("%d",&matriz[i][j]); } while(matriz[i][j]<8 || matriz[i][j]>58); matriz1[m][n]=matriz[i][j]%2; } while(matriz1[m][n]==1); col=col+5; } fil=fil+1; col=5; } col=30,fil=11; for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++) { gotoxy(col,fil);printf("%d",matriz[i][j]); col=col+5; } fil=fil+1; col=30; } col=55,fil=11; for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++) { if(i==j) {

textcolor(20); gotoxy(col,fil);cprintf("%d",matriz[i][j]); col=col+5; } } fil=fil+1; col=col+1; } col1=col-6; fil1=11; aux=lim; for(i=1;i<=lim;i++) { textcolor(3); gotoxy(col1,fil1);cprintf("%d",matriz[i][aux]); aux=aux-1; col1=col1-6; fil1=fil1+1; } gotoxy(28,23);printf("1 Continuar, 0 Salir: ");scanf("%d",&op); } while(op==1); getch(); }

ENUNCIADO TAREA2._ Como se realiza el producto algebraico de matrices. ANÁLISIS  Ingresar datos en dos matrices.  Multiplicar matrices.  Fila de la matriz multiplicar con la columna de la matriz.  Sumar el resultado de la multiplicación fila por la columna.  Guardar resultados de la suma de matrices en una nueva variable.  Visualizar producto algebraico. DESARROLLO                

Ingreso librerías en C++. En entero (int) ingreso matrices y otros variables para su desarrollo. Ingreso variables locales. Ingreso apertura del programa. Ingreso un llamado, para realizar el ingreso. Ingreso una variable que me permita ingresar un límite. Asigno for para que de vueltas tantas veces como lo indique el límite. Inserto scanf, (“%d”,&m[i][j]); para ingresar datos en la matriz. Ingreso variable de las columnas y su valor para posicionar la matriz en la pantalla. Sumo columnas y filas para que recorra la asignación de la matriz durante la ejecución de c++. Posiciono la multiplicación de filas por columna. Multiplico matriz con matriz. Asigno variable acumulador, para resultado de la multiplicación de la matriz. Ingreso un switch, más una variable para la opción que desee escoger. Inserto un case enumerado para realizar la operación escogida en la opción. Asigno un do-while para ejecutar el programa tantas veces como el usuario lo requiera, sin salir del programa.

#include<stdio.h> #include<conio.h> #include<stdlib.h> int i,col,fil,lim,op,matriz[10][10],matriz1[10][10],col1,fil1,col2,fil2,matriz2[10][10], opcion,m,n; void borde() { int i; clrscr();

for(i=1;i<=80;i++) { gotoxy(i,1);printf("¸"); gotoxy(i,24);printf("¸"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("¸"); gotoxy(80,i);printf("¸"); } } void ingreso(int lim) { int i,j; clrscr(); flushall(); col=5,fil=8; textcolor(31); gotoxy(22,2);cprintf("þþþ PRODUCTO ALGEBRAICO DE MATRICES þþþ"); textcolor(31); gotoxy(5,5);cprintf("MATRIZ ( A )"); for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++) { gotoxy(col,fil);scanf("%d",&matriz[i][j]); col=col+5; } fil=fil+1; col=5; } col1=32,fil1=8; textcolor(25); gotoxy(32,5);cprintf("MATRIZ ( B )"); for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++) { gotoxy(col1,fil1);scanf("%d",&matriz1[i][j]); col1=col1+5; } fil1=fil1+1; col1=32; } }

void producto() { int i,j; col2=55,fil2=8; textcolor(50); gotoxy(55,5);cprintf("P. ALGEBRAICO DE COL*FIL"); textcolor(20); gotoxy(50,9);cprintf("A*B="); for(i=1;i<=lim;i++) { for(m=1;m<=lim;m++) { matriz2[i][j]=0; for(j=0;j<=lim;j++) { matriz2[i][m]= matriz2[i][m]+matriz[i][j]*matriz1[j][m]; } } } for(i=1;i<=lim;i++) { for(m=1;m<=lim;m++) { gotoxy(col2,fil2);printf("%d",matriz2[i][m]); col2=col2+5; } col2=55; fil2=fil2+1; } }

void main() { do { clrscr(); borde(); textcolor(31); gotoxy(25,2);cprintf("PRODUCTO ALGEBRAICO CON MATRICES"); textcolor(9); gotoxy(5,5);cprintf("MENU DE OPCION");

gotoxy(20,8);printf("1. ==> PRODUCTO DE UNA MATRIZ"); gotoxy(20,12);printf("2. ==> SALIR"); textcolor(510); gotoxy(5,23);cprintf("Nombre: Josâ&#x20AC;&#x161; Gustavo Masaquiza"); textcolor(20); gotoxy(5,18);cprintf("Escoger una de las opciones: ");scanf("%d",&op); textcolor(27); gotoxy(5,20);cprintf("Ingresar un limite: ");scanf("%d",&lim); ingreso(lim); switch(op) { case 1: producto(1); break; case 2: exit(2); } gotoxy(28,23);printf("1 Continuar, 0 Salir: ");scanf("%d",&opcion); } while(opcion==1); getch(); }

ENUNCIADO TAREA3._ Ejercicios de Matrices y Vectores 1. Diseñe un programa que permita generar una matriz cuadrática con números primos 2. Diseñe un programa que permita generar n elementos en una matriz cuadrática con la serie del Fibonacci 3. Diseñe un programa que permita ingresar n elementos entre 1 y 32, recorrer la matriz y guardar los elementos pares en un vector y los elementos impares en otro vector se presentar los datos ordenados. 4. Diseñe un programa que permita ordenar en forma ascendente los datos de una matriz ANÁLISIS  Generar una matriz cuadrática con números primos.  Generar n elementos en una matriz cuadrática.  Matriz cuadrática con la serie de Fibonacci.

   

Ingresar n elementos entre 1 y 32. Recorrer la matriz guardar los elementos pares en un vector. Recorrer la matriz y guardar los elementos impares en otro vector. Presentar los datos ordenados.

 Ingresar datos en una matriz.  Ordenar datos de una matriz en forma ascendente.

DESARROLLO             

Ingreso librerías en C++. En entero (int) ingreso matrices y otros variables para su desarrollo. Ingreso una variable que me permita ingresar un límite. Ingreso variables locales. Ingreso apertura del programa. Valido dato de las matrices y sus variables con los valores necesitados para su asignación. Ingreso for para que corra hasta el límite indicado. Posiciono variables de columnas y filas. Utilizo printf para visualizar los datos de una matriz cuadrática de los números primos. Ingreso clrscr(); para limpiar pantalla. Utilizo flushall(); para vaciar la memoria y seguir utilizando el programa. Asigno do-while, para ingresar al menú principal y ejecutarlo tantas veces como el usuario lo requiera. Asigno otro do-while, con opciones para salir del programa o seguir en el programa.

#include<stdio.h> #include<conio.h> int i,j,b,col,fil,fil1,col1,lim,op,matriz[10][10],lim,aux,matriz1[10][10],matriz2[10][10],matri z3[10],matriz4[10],opcion,a,m,n,b,c,r[10]; void borde() { int i,j; for(i=1;i<=80;i++) { gotoxy(i,1);printf("¸"); gotoxy(i,24);printf("¸"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("¸"); gotoxy(80,i);printf("¸");

} } void primos() { flushall(); col=5,fil=10; textcolor(29); gotoxy(28,2),cprintf("M.CUADRATICA DE # PRIMOS"); textcolor(31); gotoxy(5,5);cprintf("Ingresar un limite: ");scanf("%d",&lim); col=5,fil=10; b=2; aux=1; a=2; matriz[i][j]=1; for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++) { matriz[i][j]=b; b=aux+aux+1; aux=matriz[i][j]; gotoxy(col,fil);printf("%d",matriz[i][j]); col=col+5; } fil=fil+1; col=5; }

} void fibonacci() { flushall(); textcolor(31); gotoxy(21,2);cprintf("MATRIZ CUADRATICA DE LA SERIE DE FIBONACCI"); textcolor(20); gotoxy(5,5);cprintf("Ingresar un limite: ");scanf("%d",&lim); a=1; b=0; col=5,fil=10; for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++) { matriz[i][j]=a+b; a=b; b=matriz[i][j]; gotoxy(col,fil);printf("%d",matriz[i][j]); col=col+5; } fil=fil+1; col=5; } } void paresimpares() { flushall();

textcolor(31); gotoxy(21,2);cprintf("ELEMENTOS ENTRE 1-32 DE # PARES E IMPARES"); gotoxy(5,5);printf("Ingresar un limite: ");scanf("%d",&lim); textcolor(31); gotoxy(5,8);cprintf("Ingreso de datos"); textcolor(9); gotoxy(25,8);cprintf("S.# pares"); textcolor(29); gotoxy(38,8);cprintf("S.# Impares"); col=5,fil=10; for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++) { do{ gotoxy(col,fil);printf("

");

gotoxy(col,fil);scanf("%d",&matriz[i][j]); } while(matriz[i][j]<1 || matriz[i][j]>32); col=col+5; } col=5; fil=fil+1; } col=30,fil=10; b=1; for(i=1;i<=lim;i++) {

for(j=1;j<=lim;j++) { if(matriz[i][j]%2==0) { matriz4[b]=matriz[i][j]; gotoxy(col,fil);printf("%d",matriz4[b]); b=b+1; fil=fil+1; } } } textcolor(3); gotoxy(52,8);cprintf("Pares Ord."); col=55,fil=10; aux=1; for(i=1;i<b;i++) { for(j=1;j<b;j++) { if(matriz4[i]<matriz4[j]) { aux=matriz4[i]; matriz4[i]=matriz4[j]; matriz4[j]=aux; } } } for(i=1;i<b;i++)

{ gotoxy(col,fil);printf("%d",matriz4[i]); fil=fil+1; } col=40,fil=10; b=1; for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++) { if(matriz[i][j]%2==1) { matriz4[b]=matriz[i][j]; gotoxy(col,fil);printf("%d",matriz4[b]); b=b+1; fil=fil+1; } } } textcolor(20); gotoxy(68,8);cprintf("Impares Ord."); col=70,fil=10; aux=1; for(i=1;i<b;i++) { for(j=1;j<b;j++) { if(matriz4[i]<matriz4[j])

{ aux=matriz4[i]; matriz4[i]=matriz4[j]; matriz4[j]=aux; } } } for(i=1;i<b;i++) { gotoxy(col,fil);printf("%d",matriz4[i]); fil=fil+1; } } void ordenacion() { flushall(); textcolor(3); gotoxy(17,2);cprintf("ORDENACION DE DATOS DE UNA MATRIZ DE F. ASCENDENTE"); gotoxy(5,5);printf("Ingresar un limite: ");scanf("%d",&lim); textcolor(31); gotoxy(5,8);cprintf("INGRESO DE DATOS"); textcolor(20); gotoxy(40,8);cprintf("D.M.F. ASCENDENTE"); col=5,fil=10; b=1; for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++)

{ matriz3[b]=matriz[i][j]; gotoxy(col,fil);scanf("%d",&matriz3[b]); b=b+1; col=col+5; } col=5; fil=fil+1; } col=40,fil=10; aux=1; for(i=1;i<b;i++) { for(j=1;j<b;j++) { if(matriz3[i]<matriz3[j]) { aux=matriz3[i]; matriz3[i]=matriz3[j]; matriz3[j]=aux; } } } for(i=1;i<b;i++) { gotoxy(col,fil);printf("%d",matriz3[i]); fil=fil+1; }

} void salir() { exit(); } void main() { flushall(); do{ clrscr(); borde(); textcolor(31); gotoxy(26,2);cprintf("MENU DE MATRICES CUADRATICAS"); textcolor(3); gotoxy(18,5);cprintf("1. MATRIZ CUADRATICA CON NUMEROS PRIMOS"); gotoxy(18,7);cprintf("2. GENERADOR DE LA SERIE DE FIBONACCI"); gotoxy(18,9);cprintf("3. INGRESO DE N ELEMENTOS ENTRE 1 Y 32"); gotoxy(18,11);cprintf("4. ASCENDENTE");

ORDENACION DE DATOS DE UNA MATRIZ DE F.

textcolor(20); gotoxy(18,13);cprintf("5. SALIR"); textcolor(510); gotoxy(5,21);cprintf("Nombre: Gustavo Masaquiza."); textcolor(26); gotoxy(5,19);cprintf("Escoger una de las opciones: ");scanf("%d",&opcion); switch(opcion) { case 1: flushall();

clrscr(); primos(1); break; case 2: flushall(); clrscr(); fibonacci(2); break; case 3: flushall(); clrscr(); paresimpares(3); break; case 4: flushall(); clrscr(); ordenacion(4); break; case 5: salir(5); exit(); } textcolor(31); gotoxy(28,22);cprintf("1 Continuar,0 Salir: ");scanf("%d",&op); } while(op==1); getch(); }

ENUNCIADO TAREA 4._ Diseñe un programa en c utilizando estructuras de datos para automatizar el control de una factura dentro de ella los campos que debe manejar la estructura son: Descripción del producto, cantidad, precio unitario, precio total, se ingresan tantos productos como el usuario lo requiera al final se visualizan los productos adquiridos por el cliente, con su respectivo subtotal al 12% del IVA y su total. ANÁLISIS  Ingresar datos en la estructura.  Automatizar el control de una factura.  Descripción del producto.  Cantidad.

     

Precio Unitario. Precio Total. Subtotal al 12% del IVA. Su Total. Se ingresan tantos productos como el usuario lo requiera. Al final visualizar los productos adquiridos por el cliente.

DESARROLLO              

Ingreso librerías en C++. Utilizo estructuras de datos. Ingreso tipos de variables globales como char, float, int. En entero (int) ingreso variables para su desarrollo. Ingreso apertura del programa. Utilizo un clrscr(); para limpiar pantalla. Utilizo flushall(); para vaciar la memoria de las variables. Asigno variables de tipo carácter (char) con su debida memoria para su asignación. Utilizo gotoxy para posicionarme en la pantalla. Utilizo scanf para el ingreso de datos. Utilizo gets para el ingreso de datos de tipo carácter (char). Utilizo printf para visualizar los datos. También utilizo puts para visualizar los datos de tipo carácter (char). Asigno do-while, para ejecutar el programa tantas veces como el usuario lo requiera.

#include<stdio.h> #include<conio.h> #include<stdlib.h> void main() { struct datos { char product[15],nombre[15],fecha[15]; float iva,total; int factura,cantidad,punitario,op,subtotal,ptotal; }datos[15]; int fact,lim,col,fil,i,ptotal,cantidad[15],punitario[15],op,a,b,subtotal[15]; float iva,total=0; char nombre[15],fecha[15]; do { clrscr(); for(i=1;i<=80;i++) {

gotoxy(i,1);printf("þ"); gotoxy(i,24);printf("þ"); gotoxy(i,8);printf("þ"); gotoxy(i,10);printf("þ"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("þ"); gotoxy(80,i);printf("þ"); } for(i=10;i<=24;i++) { gotoxy(23,i);printf("þ"); gotoxy(47,i);printf("þ"); gotoxy(69,i);printf("þ"); } flushall(); textcolor(31); gotoxy(35,2);cprintf("NOTA DE VENTA"); textcolor(13); gotoxy(3,5);cprintf("N.Factura: ");scanf("%d",&fact); flushall(); textcolor(26); gotoxy(50,5);cprintf("Fecha: ");gets(fecha); flushall(); textcolor(36); gotoxy(3,7);cprintf("Nombre del Cliente: ");gets(nombre); flushall(); textcolor(31); gotoxy(3,9);cprintf("Ingresar un limite de compra: ");scanf("%d",&lim); gotoxy(3,11);cprintf("Producto Cantidad P.Unitario P.Total"); col=3; for(i=1;i<=lim;i++) { flushall(); gotoxy(col,i+13);gets(datos[i].product); flushall(); gotoxy(col+22,i+13);scanf("%d",&datos[i].cantidad); flushall(); gotoxy(col+46,i+13);scanf("%d",&datos[i].punitario); datos[i].ptotal=datos[i].cantidad * datos[i].punitario; gotoxy(col+69,i+13);printf("%d",datos[i].ptotal); } clrscr(); for(i=1;i<=80;i++)

{ gotoxy(i,1);printf("þ"); gotoxy(i,24);printf("þ"); gotoxy(i,8);printf("þ"); gotoxy(i,10);printf("þ"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("þ"); gotoxy(80,i);printf("þ"); } for(i=10;i<=24;i++) { gotoxy(23,i);printf("þ"); gotoxy(47,i);printf("þ"); } for(i=10;i<=20;i++) { gotoxy(69,i);printf("þ"); } for(i=47;i<=80;i++) { gotoxy(i,19);printf("þ"); } textcolor(31); gotoxy(35,2);cprintf("NOTA DE VENTA"); textcolor(13); gotoxy(3,5);cprintf("N.Factura: ");printf("%d",fact); textcolor(26); gotoxy(50,5);cprintf("Fecha: ");puts(fecha); textcolor(31); gotoxy(3,7);cprintf("Nombre del Cliente: ");puts(nombre); textcolor(20); gotoxy(3,9);cprintf("Ingresar un limite de compra: ");printf("%d",lim); textcolor(3); gotoxy(3,11);cprintf("Producto Cantidad P.Unitario P.Total"); col=3; for(i=1;i<=lim;i++) { flushall(); gotoxy(col,i+13);puts(datos[i].product); flushall(); gotoxy(col+22,i+13);printf("%d",datos[i].cantidad); flushall();

gotoxy(col+46,i+13);printf("%d",datos[i].punitario); datos[i].ptotal=datos[i].cantidad * datos[i].punitario; datos[a].subtotal=datos[i].ptotal; gotoxy(col+69,i+13);printf("%d",datos[i].ptotal); } col=60,fil=20; textcolor(13); gotoxy(col,fil);cprintf("Subtotal: %d",datos[a].subtotal); iva=datos[a].subtotal*0.12; gotoxy(col+2,fil+1);cprintf("12 IVA: %2.2f",iva); total=datos[a].subtotal+iva; gotoxy(col+3,fil+2);cprintf("Total: %2.2f",total); flushall(); textcolor(510); gotoxy(25,23);cprintf("1 Continuar,0 Salir: ");scanf("%d",&op); } while(op==1); getch(); }

ENUNCIADO TAREA5._ Realizar un programa que me permita realizar cuatro operaciones básicas en un menú de opciones, las cuales deben tener funciones y matrices. ANÁLISIS  Ingresar datos en una matriz.

 Visualizar menú de opciones de las operaciones básicas.  Realizar cuatro operaciones básicas.  Con funciones y matrices. DESARROLLO                 

Ingreso librerías en C++. En entero (int) ingreso matrices y otros variables para su desarrollo. Ingreso variables globales. Ingreso apertura del programa. Valido dato de las matrices y sus variables con los valores necesitados para su asignación. Ingreso una variable que me permita ingresar un límite. Ingreso for para que corra hasta el límite solicitado. Posiciono filas y columnas para el ingreso de datos, como la visualización de los datos. Utilizo flushall(); para vaciar la memoria de las variables. Opero variables según la librería que toque. Para ello realizo un menú de opciones enumeradas con su respectiva operación. Sumo matrices, para la suma y guardo su resultado en otra matriz. Resto matrices, para la resta y guardo su resultado en otra matriz. Multiplico matrices, para la multiplicación y guardo su resultado en otra matriz. Divido matrices, para la división y guardo su resultado en otra matriz. Utilizo un clrscr(); para limpiar pantalla. Ingreso do-while para recorrer el programa tantas veces como el usuario lo requiera.

#include<stdio.h> #include<conio.h> #include<stdlib.h> int i,col,fil,lim,op,matriz[10][10],matriz1[10][10],col1,fil1,col2,fil2,matriz2[10][10], opcion; void borde() { int i; clrscr(); for(i=1;i<=80;i++) { gotoxy(i,1);printf("¸"); gotoxy(i,24);printf("¸"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("¸");

gotoxy(80,i);printf("¸"); } } void ingreso(int lim) { int i,j; clrscr(); flushall(); col=5,fil=8; textcolor(28); gotoxy(25,2);cprintf("þþþ OPERACIàN DE MATRICES þþþ"); gotoxy(5,5);printf("MATRIZ 1"); for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++) { gotoxy(col,fil);scanf("%d",&matriz[i][j]); col=col+5; } fil=fil+1; col=5; } col1=32,fil1=8; gotoxy(32,5);printf("MATRIZ 2"); for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++) { gotoxy(col1,fil1);scanf("%d",&matriz1[i][j]); col1=col1+5; } fil1=fil1+1; col1=32; } } void suma() { int i,j; flushall(); col2=55,fil2=8; gotoxy(55,5);printf("RESULTADO DE M.1 Y 2"); for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++) { matriz2[i][j]=matriz[i][j]+matriz1[i][j]; gotoxy(col2,fil2);printf("%d",matriz2[i][j]);

col2=col2+5; } fil2=fil2+1; col2=55; } } void resta() { int i,j; col2=55,fil2=8; gotoxy(55,5);printf("RESULTADO DE M.1 Y 2"); for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++) { if(matriz1[i][j]>matriz[i][j]) { matriz2[i][j]=matriz1[i][j]-matriz[i][j]; } else { matriz2[i][j]=matriz[i][j]-matriz1[i][j]; } gotoxy(col2,fil2);printf("%d",matriz2[i][j]); col2=col2+5; } fil2=fil2+1; col2=55; } } void multiplicacion() { int i,j; col2=55,fil2=8; gotoxy(55,5);printf("RESULTADO DE M.1 Y 2"); for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++) { matriz2[i][j]=matriz[i][j]*matriz1[i][j]; gotoxy(col2,fil2);printf("%d",matriz2[i][j]); col2=col2+5; } fil2=fil2+1; col2=55;

} } void division() { int i,j; col2=55,fil2=8; gotoxy(55,5);printf("RESULTADO DE M.1 Y 2"); for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++) { matriz2[i][j]=matriz[i][j]/matriz1[i][j]; gotoxy(col2,fil2);printf("%d",matriz2[i][j]); col2=col2+6; } fil2=fil2+1; col2=55; } } void main() { do { clrscr(); borde(); textcolor(31); gotoxy(30,2);cprintf("OPERACION CON MATRICES"); textcolor(9); gotoxy(5,5);cprintf("MENU DE OPCIONES"); gotoxy(20,7);printf("1. ==> SUMA"); gotoxy(20,9);printf("2. ==> RESTA"); gotoxy(20,11);printf("3. ==> MULTIPLICACIàN"); gotoxy(20,13);printf("4. ==> DIVISIàN"); gotoxy(20,15);printf("5. ==> SALIR"); textcolor(20); gotoxy(5,18);cprintf("Escoger una de las opciones: ");scanf("%d",&op); textcolor(27); gotoxy(5,20);cprintf("Ingresar un limite: ");scanf("%d",&lim); ingreso(lim); switch(op) { case 1: suma(1); break; case 2: resta(2);

break; case 3: multiplicacion(3); break; case 4: division(4); break; case 5: exit(5); break; } gotoxy(28,23);printf("1 Continuar, 0 Salir: ");scanf("%d",&opcion); } while(opcion==1); getch(); }

SUMA

RESTA

MULTIPLICACIÓN

DIVISIÓN

ENUNCIADO TAREA6._ Diseñe un programa utilizando Matrices y Funciones que permita: 1. Ingresar n elementos en una matriz con datos entre 5 y 35, excluyendo las diagonales principal y secundaria, en dónde la diagonal principal se llena con la serie del Fibonacci y la diagonal secundaria con la factorial de los números ascendentes iniciando en 3. 2. Recorra la matriz y guarde los datos de la diagonal principal en las posiciones pares del vector y los datos de la diagonal segundaria en las posiciones impares del vector. 3. Presente como resultado el vector origen resultante y el mismo vector preséntelo impreso en forma descendente. ANÁLISIS     

Ingresar datos en una matriz. Validar datos entre 5 y 35. Excluyo la diagonal principal y secundaria. Diagonal principal se llena con la serie de Fibonacci. Diagonal secundaria con la factorial de los números ascendentes iniciado en 3.  Recorro la matriz y guardo los datos de la diagonal principal en las posiciones pares del vector.  Datos de la diagonal secundaria en las posiciones impares del vector.  Vector resultante presentar impreso en forma descendente. DESARROLLO             

Ingreso librerías en C++. En entero (int) ingreso matrices y otros variables para su desarrollo. Ingreso una variable para el límite. Posiciono columnas y filas con gotoxy para el ingreso de datos. Utilizo un do-while para validar datos entre 5 y35. Asigno un for para que recorra tantas veces como el límite lo indique. Asigno un if para la condición que diga que si la variable (i) es igual a variable (j) pues se imprima según la condición de columnas y filas. Utilizo un flushall(); para vaciar la memoria de la variable. Ingreso columnas y filas para un nuevo posicionamiento de la impresión de diagonal principal y secundaria. Valido variables que inicialicen según lo necesitado. Sumo columnas con columnas, para recorrer las columnas en la impresión. Sumo filas con filas para ascender filas según lo necesario. Ingreso una variable auxiliar que diga aux=limite, en la cual auxiliar es igual al límite.

 Para imprimir diagonales secundarios le resto columnas por columnas y sumo filas más uno.  Asigno do-while para seguir ejecutando tantas veces como el usuario lo requiera.  Y también asigno clrscr(); para limpiar pantalla durante una nueva asignación. #include<stdio.h> #include<conio.h> #include<math.h> void main() { int m[10][10],m1[10],m2[10][10],i,j,f,c,n,op,l,a,b,c1,f1,aux; do { clrscr(); flushall(); for(i=1;i<=80;i++) { gotoxy(i,1);printf("þ"); gotoxy(i,24);printf("þ"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("þ"); gotoxy(80,i);printf("þ"); } c=5; f=8; textcolor(3); gotoxy(25,2);cprintf("OPERACIONES CON MATRICES ENTRE 5-35");

textcolor(20); gotoxy(5,5);cprintf("Ingrese Lยกmite :");scanf("%d",&l); gotoxy(5,7);printf("MATRIZ");

for(i=1;i<l+1;i++) { for(j=1;j<l+1;j++) { do { gotoxy(c,f);printf(" "); gotoxy(c,f);scanf("%d",&m[i][j]); } while((m[i][j])<=4|| (m[i][j])>=36); c=c+5; } c=5; f=f+1; } c=24; f=8; gotoxy(24,7);printf("DiagonaL 1 y 2"); for(i=1;i<l+1;i++) { for(j=1;j<l+1;j++) { if(i==j) {

gotoxy(c,f);printf("%d",m[i][j]); c=c+3; } } c=c+1; f=f+1; } flushall(); c1=c-4; f1=8; aux=l; for(i=1;i<=l;i++) { gotoxy(c1,f1);printf("%d",m[i][aux]); aux=aux-1; c1=c1-4; f1=f1+1; } flushall(); gotoxy(41,7);printf("DiagonaL [1]"); c=45; f=8; a=1,b=0; for(i=1;i<=l;i++) { for(j=1;j<=l;j++) { m[i][j]=a+b;

a=b; b=m[i][j]; gotoxy(c,f);printf("%d",m[i][j]); c=c+3; f=f+1; } } flushall(); gotoxy(64,7);printf("DiagonaL [2]"); c1=c-3; f1=8; aux=l; for(i=1;i<=l+aux+l;i++) { m1[i]=i*3; m2[i][aux]=m1[i]; gotoxy(c1,f1);printf("%d",m2[i][aux]); c1=c1-3; f1=f1+1; } textcolor(31); gotoxy(27,22);cprintf("1 Ciontinuar,0 Salir: ");scanf("%d",&op); } while(op==1); getch(); }

BIBLIOGRAFĂ?A http://asysistems.blogspot.com/2008/05/definicion-de-matriz.html http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Tipos_de_datos http://www.zator.com/Cpp/E4_3.htm http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Vectores