CARRERA DE DOCENCIA EN INFORMÁTICA Y COMPUTACIÓN

NOMBRE:

VALERIA RUIZ

TEMA:

VECTORES Y MATRICES EN LENGUAJE C

SEMESTRE:

TERCERO

INGENIERA:

WILMA GAVILANEZ

ÍNDICE

ÍNDICE ---------------------------------------------------------------------------------------------------------- 2

VECTOR -------------------------------------------------------------------------------------------------------- 3

SINTAXIS ------------------------------------------------------------------------------------------------------------------ 3

Tipo: ----------------------------------------------------------------------------------------------------------------- 3

Identificado: ------------------------------------------------------------------------------------------------------- 3

Tamaño: ------------------------------------------------------------------------------------------------------------- 3

Un vector puede ser: ----------------------------------------------------------------------------------------------------- 3

MATRIZ -------------------------------------------------------------------------------------------------------- 3

Int: ------------------------------------------------------------------------------------------------------------------- 3

Matriz: --------------------------------------------------------------------------------------------------------------- 3

Las matrices: ------------------------------------------------------------------------------------------------------- 3

EJERCICIOS CON VECTORES Y MATRICES -------------------------------------------------------- 3

GRÁFICO 1 ---------------------------------------------------------------------------------------------------- 6

GRÁFICO 2 ---------------------------------------------------------------------------------------------------- 9

GRÁFICO 3 --------------------------------------------------------------------------------------------------- 12

GRÁFICO 4 --------------------------------------------------------------------------------------------------- 15

GRÁFICO 5 --------------------------------------------------------------------------------------------------- 20

GRÁFICO 6 --------------------------------------------------------------------------------------------------- 23

VECTOR

Un vector, también llamado array(arreglo) unidimensional, es una estructura de datos que permite agrupar elementos del mismo tipo y almacenarlos en un solo bloque de memoria juntos, uno después de otro. A este grupo de elementos se les identifica por un mismo nombre y la posición en la que se encuentran. La primera posición del array es la posición 0.

SINTAXIS

<Tipo> <identificador> [<tamaño>]; Tipo: tipo de dato de los elementos del vector Identificado: identificador de la variable. Tamaño: número de elementos del vector.

Un vector puede ser:

Un literal o una constante de tipo entero

MATRIZ Una matriz es un vector de vectores o un también llamado array bidimensional.

int matriz[filas][columnas];

Int: es el tipo de dato. Matriz: es el nombre del todo el conjunto de datos y debo de especificar el número de filas

y columnas. Las matrices: también pueden ser de distintos tipos de datos como char, float,

double,etc

EJERCICIOS CON VECTORES Y MATRICES 1º. Validar el ingreso de datos entre 13 y 28. Ingrese n datos dentro de un vector y visualizar en

pantalla. #include<stdio.h> #include<conio.h>

Tipo de dato int vector[10] tamaño de la variable variable

void main() { int x,i,l,v[20],f1,f2,c,m,b; flushall(); do{ clrscr(); for(b=1;b<=80;b++) { gotoxy(b,3);printf("*"); gotoxy(b,50);printf("*"); } for(b=1;b<=50;b++) { gotoxy(1,b);printf("*"); gotoxy(80,b);printf("*"); } gotoxy(30,3);printf("Ingreso y Salida de Vectores"); gotoxy(8,5);printf("Ingrese el l¡mite: ");scanf("%d",&l); f1=10; f2=10; c=15; for(i=1;i<=l;i++) { do{ gotoxy(8,8);printf("Datos de Entrada"); gotoxy(c,f1);printf(“ “); gotoxy(c,f1);scanf("%d",&v[i]); } while(v[i]<13 ||v[i]>=28); f1=f1+1; } for(i=1;i<=l;i++) { gotoxy(28,8);printf("Datos de salida"); gotoxy(c,f1);printf(" "); gotoxy(c+20,f2);printf("%d",v[i]); f2=f2+1; } gotoxy(20,44);printf("Presione 1 para continuar o 0 para salir: ");scanf("%d",&x); } while(x==1); }

ANÁLISIS 1

Para desarrollar este programa se utiliza las librerías #include <stdio.h> y #include<conio.h> Inicializo el programa void main (), y abro llaves {.declar Declaro las variables como son de tipo entero utilizo int En la siguiente línea de código esta flushall(); que sirve para un vaciado de memoria. Para un borrado de pantalla utilizo clrscr() en cada finalización de línea de código coloco punto y

como (;). Para el borde en un for(b=1;b<=80;b++), con un posicionamiento en pantalla

gotoxy(b,3);printf("*"); gotoxy(b,50);printf("*"); para que en la columna se me imprima el asterisco, en la fila 3, igualmente en la fila 80. Cierro la llave de for

Otro for para las filas for(b=1;b<=50;b++) { gotoxy(1,b);printf("*"); gotoxy(80,b);printf("*"); } Imprimo en pantalla un mensaje para ello utilizo gotoxy(30,3);printf("Ingreso y Salida de

Vectores"); Ingreso un límite desde teclado gotoxy(8,5);printf("Ingrese el limite: ");scanf("%d",&l); Declaro que la fila1 sea f1=10;, la fila2 f2=10; la columna c=15; Para recorrer los datos utilizo un ciclo for(i=1;i<=l;i++) { Dentro de este for valido el ingreso, con un ciclo repetitivo do{ Ingreso un dato desde teclado gotoxy(c,f1);scanf("%d",&v[i]); Condiciono el ciclo repetitivo como funciona por el lado verdadero while(v[i]<13 ||v[i]>=28); si

no cumple la condición vuelve a pedir que ingrese un dato Declaramos que la fila1 f1=f1+1; Y cerramos la llave del for }

GRÁFICO 1

2º. Diseñe un programa que me permita ingresar datos en una matriz y visualizar la matriz resultante en pantalla. #include<stdio.h> #include<conio.h> int i,k,j,l,f,c,op; int matriz1[3][3]; void borde() { for(i=1;i<=60;i++) { gotoxy(i,1);printf("%",i); gotoxy(i,24);printf("%",i); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("%",i); gotoxy(60,i);printf("%",i); } } void main() { do

{ clrscr(); borde(); gotoxy(5,5);printf("ingrese un limite ");scanf("%d",&l); c=10; f=10; for(j=1;j<=l;j++) { for(k=1;k<=l;k++) { gotoxy(c,f);scanf("%d",&matriz1[j][k]); c=c+5; } c=10; f=f+1; } c=25; f=10; for(j=1;j<=l;j++) { for(k=1;k<=l;k++) { gotoxy(c,f);printf("%d",matriz1[j][k]); c=c+5; } c=25; f=f+1; } gotoxy(10,20);printf("1 para seguir y 0 para salir");scanf("%d",&op); } while(op==1); getch(); }

ANÁLISIS 2 Inicializamos el programa con las librerías #include<stdio.h> y #include<conio.h> Declaramos

las variables de forma global, como son de tipo entero utilizo int. Para la matriz utilizo una variable matriz1[3][3] en donde declare el numero de filas y columnas. Al terminar todas las líneas de código coloco punto y coma.

Coloco un mensaje en pantalla para que el usuario ingrese el límite de la matriz , para ello con un posicionamiento en pantalla utilizo gotoxy(5,5);

En donde el primer 5 es el posicionamiento de la columna y el segundo 5 es el posicionamiento de la fila.

Precedido del gotoxy printf("ingrese un límite "); para que se visualice en la pantalla, scanf("%d",&l); para que me permita ingresar un dato desde teclado, como es un dato de tipo entero utilizo %d.

Dentro del programa principal declaro que la columna empiece en 10 ,c=10; y la fila en f=10; Para recorrer los datos de una matriz utilizó dos for el primer for(j=1;j<=l;j++) abro el ciclo for

con las llaves{ el segundo for , for(k=1;k<=l;k++), cin otra variable diferente del primer for, igualmente abro las llaves {

Par ingresar datos desde teclado pata una matriz con un posicionamiento en pantalla gotoxy(c,f); scanf("%d",&matriz1[j][k]);

Dentro del for decimos que la columna me incremente 5, para ello, c=c+5; y cierro el primer for con la llave cerrada }

Declaro que la columna sea igual a c=10; Y la fila se aumente una posición más. f=f+1; y cerramos las llaves del segundo for } Pata que se visualice la matriz resultante realizamos el mismo procedimiento solo que en vez de

ingresar datos desde teclado decimos que se me imprima la matriz para ello gotoxy(c,f);printf("%d",matriz1[j][k]);

Con diferentes posicionamientos en pantalla. Para repetir el proceso colocamos un ciclo do antes de pedir que ingresemos el límite. Abrimos

las llaves del do { y colocamos un clrscr(); para un borrado de pantalla antes del getch(); que sirve para hacer una pausa en el programa colocamos un mensaje gotoxy(10,20);printf("1 para seguir y 0 para salir");scanf("%d",&op); para que el usuario ingrese un valor. Cerramos las llaves del do y condicionamos que la opción seleccionada es igual a 1 entonces se repita el proceso para ello while(op==1);

Y finalmente cerramos las llaves del programa principal }

GRÁFICO 2

3º. Diseñe un programa que me permita generar los múltiplos de un número y visualizarlos en pantalla.

#include<stdio.h> #include<conio.h> int i,fac,l,f,c,op,k,j,a; int matriz[3][3]; void borde() { for(i=1;i<=24;i++) { gotoxy(1,i);printf("*",i); gotoxy(60,i);printf("*",i); } for(i=1;i<=60;i++) { gotoxy(i,1);printf("*",i); gotoxy(i,24);printf("*",i); } }

void main() { do { clrscr(); borde(); c=5; f=6; gotoxy(2,2);printf("ingrese un limite ");scanf("%d",&l); do { gotoxy(20,4);printf(" "); gotoxy(2,4);printf("ingrese el factor ");scanf("%d",&fac); } while(fac<2||fac>9); a=1; for(j=1;j<=l;j++) { for(k=1;k<=l;k++) { matriz[j][k]=fac*a; gotoxy(c,f);printf("%d",matriz[j][k]); a=a+1; c=c+3; } f=f+1; c=5; } c=40; f=6; a=1; for(j=1;j<=l;j++) { for(k=1;k<=l;k++) { matriz[j][k]=fac*a; gotoxy(c,f);printf("%d",matriz[j][k]); a=a+1; c=c+3; } f=f+1; c=40;

} gotoxy(10,20);printf("1 para seguir 0 para salir ");scanf("%d",&op); } while(op==1); getch(); }

ANÁLISIS 3

Igualmente colocamos las librerías iníciales #include<stdio.h> #include<conio.h> Declaro las variable como son enteros utilizo int Para validar el ingreso utilizo un ciclo do { en donde condiciono while(fac<2||fac>9);

como funciona por el lado verdadero si no cumple la condición vuele a pedir que ingrese otro valor. Para que se borre el dato que no es el correcto coloco gotoxy(20,4);printf(" ");

Utilizo dos for, dentro de los dos for con un contador en este caso utilice a matriz[j][k]=fac*a; la matriz es igual al factor ingresado desde teclado por el contador y que se imprima la matriz.

Con posicionamiento en pantalla gotoxy(c,f);printf("%d",matriz[j][k]); Dentro del for declaro que a, a=a+1; Fuera de los dos for declaro que a=1; Antes de cerrar el for f=f+1;pta que la fila se me incremente 1 Cerramos las llaves del for y del programa principal

GRÁFICO 3

4º. Diseñe un programa que me permita ingresar n elementos enteros en una matriz cuadrática los mismos que deben estar en un rango desde 5 hasta 45, recorra la matriz y encuentre todas los elementos impares de la matriz y guárdelos en un vector, el mismo que se debe presentar en forma ordenada #include<stdio.h> #include<conio.h> int i,j,k,l,c,f,a,c1,f1,f2,aux,op; int num[10][10],vec[10]; void borde() { for(i=1;i<=25;i++) { gotoxy(1,i);printf("/"); gotoxy(80,i);printf("/"); } for(i=1;i<=80;i++) { gotoxy(i,2);printf("/"); gotoxy(i,25);printf("/"); } }

void main() { do { clrscr(); borde(); gotoxy(5,5);printf("INGRESE UN LIMITE ");scanf("%d",&l); c=5; f=10; for(j=1;j<=l;j++) { for(k=1;k<=l;k++) { do { gotoxy(5,8);printf("MATRIZ"); gotoxy(c,f);printf(" "); gotoxy(c,f);scanf("%d",&num[j][k]); } while(num[j][k]<5||num[j][k]>45); c=c+4; } c=5; f=f+1; } //impares a=1; c1=25; f1=10; for(j=1;j<=l;j++) { for(k=1;k<=l;k++) { if(num[j][k]%2==1) { vec[a]=num[j][k]; gotoxy(22,8);printf("IMPARES"); gotoxy(c1,f1);printf("%d",vec[a]); a=a+1; f1=f1+1; } }

} //ordenada aux=1; f2=10; for(j=1;j<a;j++) { for(k=1;k<a;k++) { if(vec[j]<vec[k]) { aux=vec[j]; vec[j]=vec[k]; vec[k]=aux; } } } for(j=1;j<a;j++) { gotoxy(40,8);printf("ORDENADO"); gotoxy(45,f2);printf("%d",vec[j]); f2=f2+1; } gotoxy(5,22);printf("1 PARA CONTINUAR Y 0 PARA SALIR ");scanf("%d",&op); } while(op==1); getch(); }

ANÁLISIS 4

Dentro de los dos for que se utiliza para ingresar datos en una matriz, validamos el ingreso utilizando un ciclo do { while(num[j][k]<5||num[j][k]>45); en donde si el numero ingresado es el adecuado continua, caso contrario vuelve a pedir que ingrese un numero.

Para ingresar datos desde teclado utilizo gotoxy(c,f);scanf("%d",&num[j][k]); Para recorrer los datos de una matriz y encontrar los números pares de esa matriz utilizo

igualmente dos for de la matriz que ingresamos los datos en donde condicionamos if(num[j][k]%2==1). Si cumple con esta condición entonces se me va a guardar los datos en un vector vec[a]=num[j][k];

Con posicionamiento en pantalla imprimimos el vector gotoxy(c1,f1);printf("%d",vec[a]); Declaramos que a es el nuevo límite del vector resultante a=a+1; Para ordenar el vector resultante con auxiliar que sea igual a 1, aux=1; Dentro de los dos for, for(j=1;j<a;j++), hasta a porque es el nuevo límite del vector

Con un condicionador if(vec[j]<vec[k]) Entonces aux=vec[j]; vec[j]=vec[k]; vec[k]=aux; Cierro las llaves de los dos for y de la condición Dentro de un for que se inicialice en 1 hasta que sea menor a a, y que se incremente de uno

en uno for(j=1;j<a;j++) abrimos las llaves del for { E imprimo el vector con gotoxy(45,f2);printf("%d",vec[j]);

GRÁFICO 4

5º. 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 presentan los datos ordenados. #include<stdio.h> #include<conio.h> int i,b,c1,f,op,opc,j,k,l,a,c,r,c2,f2,c3,f1,aux; int matriz1[10][10],vec[10],vec1[10]; void borde() {

for(i=1;i<=25;i++) { gotoxy(1,i);printf("@",i); gotoxy(80,i);printf("@",i); } for(i=1;i<=80;i++) { gotoxy(i,2);printf("@",i); gotoxy(i,25);printf("@",i); } } void numeros() { for(j=1;j<=l;j++) { for(k=1;k<=l;k++) { do { gotoxy(c1,f);printf(" "); gotoxy(c1,f);scanf("%d",&matriz1[j][k]); } while(matriz1[j][k]<1||matriz1[j][k]>32); c1=c1+9; } c1=5; f=f+1; } //pares c2=30; f1=10; a=1; for(j=1;j<=l;j++) { for(k=1;k<=l;k++) { if(matriz1[j][k]%2==0) { vec[a]=matriz1[j][k]; a=a+1; f1=f1+1; }

} } //impares f2=10; c3=38; b=1; for(j=1;j<=l;j++) { for(k=1;k<=l;k++) { if(matriz1[j][k]%2==1) { vec1[b]=matriz1[j][k]; b=b+1; f2=f2+1; } } } //ordenado for(j=1;j<a;j++) { for(k=1;k<a;k++) { if(vec[j]<vec[k]) { aux=vec[j]; vec[j]=vec[k]; vec[k]=aux; } } } aux=1; f1=10; for(j=1;j<a;j++) { gotoxy(45,f1);printf("%d",vec[j]); f1=f1+1; } //oredenado impares for(j=1;j<b;j++)

{ for(k=1;k<b;k++) { if(vec1[j]<vec1[k]) { aux=vec1[j]; vec1[j]=vec1[k]; vec1[k]=aux; } } } aux=1; f1=10; for(j=1;j<b;j++) { gotoxy(55,f1);printf("%d",vec1[j]); f1=f1+1; } } void main() { do { clrscr(); borde(); c1=5; c2=30; f=10; c3=38; f1=10; f2=10; gotoxy(10,5);printf("NUMEROS PARES E IMPARES"); gotoxy(5,7);printf("INGRESE UN LIMITE ");scanf("%d",&l); gotoxy(5,9);printf("MATRIZ"); gotoxy(43,9);printf("PARES"); gotoxy(51,9);printf("IMPARES"); numeros(); gotoxy(5,20);printf("SELECCIONE 1 PARA CONTINUAR Y 0 PARA SALIR ");scanf("%d",&opc); } while(opc==1); getch(); }

ANÁLISIS 5

Colocamos dos for que se utiliza para ingresar datos en una matriz, validamos el ingreso utilizando un ciclo do { while(matriz1[j][k]<1||matriz1[j][k]>32);

en donde si el número ingresado es el adecuado continuo, caso contrario vuelve a Inicializo el programa con las librerías #include<stdio.h> #include<conio.h>

En una función llamada void numeros() pedir que ingrese un número. Para ingresar datos desde teclado utilizo gotoxy(c,f);scanf("%d",&num[j][k]); Para recorrer los datos de una matriz y encontrar los números pares de esa matriz utilizo

igualmente dos for de la matriz que ingresamos los datos en donde condicionamos if(matriz1[j][k]%2==0)

Si cumple con esta condición entonces se me va a guardar los datos en un vector vec[a]=matriz1[j][k];

Con posicionamiento en pantalla imprimimos el vector gotoxy(c1,f1);printf("%d",vec[a]); Para encontrar los números impares la condición es if(matriz1[j][k]%2==1) e imprimo el

vector gotoxy(55,f1);printf("%d",vec1[j]); Declaramos que a es el nuevo límite del vector resultante a=a+1; Para ordenar el vector resultante con auxiliar que sea igual a 1, aux=1; Dentro de los dos for, for(j=1;j<a;j++), hasta a porque es el nuevo límite del vector Con un condicionado if(vec[j]<vec[k]) Entonces aux=vec[j]; vec[j]=vec[k]; vec[k]=aux; Cierro las llaves de los dos for y de la condición Dentro de un for que se inicialice en 1 hasta que sea menor a a, y que se incremente de uno

en uno for(j=1;j<a;j++) abrimos las llaves del for { E imprimo el vector con gotoxy(45,f1);printf("%d",vec[j]); El mismo procedimiento para los números impares Dentro del programa principal void main() ingresamos el limite gotoxy(5,7);printf("INGRESE UN LIMITE ");scanf("%d",&l); Y llamamos a la función numeros();

GRÁFICO 5

6º. Producto algebraico de una matriz cuadrática.

#include<stdio.h> #include<conio.h> int l,c,c1,c2,f,f1,f2,k,i,j,op,a; int matriz1[10][10],matriz2[10][10],matriz3[10][10]; void borde() { for(i=1;i<=25;i++) { gotoxy(1,i);printf("@",i); gotoxy(80,i);printf("@",i); } for(i=1;i<=80;i++) { gotoxy(i,2);printf("@",i); gotoxy(i,25);printf("@",i); } } void ingreso() { for(i=1;i<=l;i++) {

for(j=1;j<=l;j++) { gotoxy(c,f);scanf("%d",&matriz1[i][j]); c=c+5; } c=5; f=f+1; } for(i=1;i<=l;i++) { for(j=1;j<=l;j++) { gotoxy(c1,f1);scanf("%d",&matriz2[i][j]); c1=c1+5; } c1=25; f1=f1+1; } } void producto() { for(i=0;i<=l;i++) { for(j=0;j<=l;j++) { matriz3[i][j]=0; for(k=0;k<=l;k++) { matriz3[i][j]=matriz3[i][j]+matriz1[i][k]*matriz2[k][j]; } } } for(i=1;i<=l;i++) { for(k=1;k<=l;k++) { gotoxy(c2,f2);printf("%d",matriz3[i][k]); c2=c2+4; } c2=42; f2=f2+1; }

} void main() { do { clrscr(); borde(); c=5; c1=25; c2=42; f=10; f1=10; f2=10; gotoxy(10,3);printf("PRODUCTO ALGEBRAICO DE UNA MATRIZ"); gotoxy(10,5);printf("INGRESE UN LIMITE ");scanf("%d",&l); gotoxy(5,7);printf("MATRIZ1"); gotoxy(25,7);printf("MATRIZ2"); gotoxy(38,7);printf("MATRIZ RESULTANTE"); ingreso(); producto(); gotoxy(8,20);printf("seleccione 1 para continuar y 0 para salir ");scanf("%d",&op); } while(op==1); getch(); }

ANÁLISIS 6

Inicializamos el programa con las librerías iniciales #include<stdio.h> #include<conio.h> Declaramos las variables como con enteros int l,c,c1,c2,f,f1,f2,k,i,j,op,a; int

matriz1[10][10],matriz2[10][10],matriz3[10][10]; Utilizo tres variables para las matrices. Las dos matrices que ingreso desde teclado y la

tercera es la matriz resultante. Dentro de una función llamada void ingreso(), ingreso los datos de las dos matrices Para ingresar las datos de la primera matriz utilizo dos for, for(i=1;i<=l;i++){

for(j=1;j<=l;j++) { Dentro de estos ciclos, gotoxy(c,f);scanf("%d",&matriz1[i][j]); para ingresar datos desde

teclado como son de tipo en entero %d La columna c=c+5;cerramos las llaves del primer for } Declaramos que la columna es c=5; y la fila sea f=f+1; y cerramos las llaves del segundo

for. El mismo procedimiento para ingresar los datos de la segunda matriz. Pero con diferentes posicionamientos de pantalla

En otra función llamada void producto() para realizar el producto algebraico de las matrices

Abrimos las llaves de la función producto. Dentro de dos for, que se inicialice en 0, hasta que sea menor o igual al límite, y se incremente de 1 en 1, for(i=0;i<=l;i++) { for(j=0;j<=l;j++) { , declaramos que la matriz resultante sea igual a 0 matriz3[i][j]=0;

Luego colocamos otro for, for(k=0;k<=l;k++) { Declaramos que matriz3[i][j]=matriz3[i][j]+matriz1[i][k]*matriz2[k][j]; Cerramos las llaves de los tres for. Y dentro de dos for mas imprimimos la matriz resultante for(i=1;i<=l;i++) {

for(k=1;k<=l;k++) { gotoxy(c2,f2);printf("%d",matriz3[i][k]); Que la columna sea igual a c2=c2+4;cerramos las llaves del un for } Declaramos que la columna sea igual a c2=42; y la fila f2=f2+1; Cerramos las llaves del segundo for y la llaves de la función Dentro del programa principal void main(). Ingresamos el limite gotoxy(10,5);printf("INGRESE UN LIMITE ");scanf("%d",&l); Y llamamos a la función ingreso(); y producto();

GRÁFICO 6