********************************************************

PROGRAMACION APLICADA A LA INGENIERIA CIVIL OOCC

GUIA N3
Ayudante: Rodrigo Torres Aguirre/2009
Compilador utilizado: Dev-C++ versin 4.9.9.2
*********************************************************
1-Construya un programa en C que permita llenar un vector de nmeros enteros de largo
MAX con nmeros aleatorios. Finalmente ordenarlos e indicar cuantas iteraciones fueron
necesarias para lograrlo.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define max 6
//LLENAR EL VECTOR O ARREGLO DE FORMA MANUAL (para el ejercicio no es necesario)
void llenar_vector(int V[max]){
int i;
for(i=0;i<max;i++){
printf("[%d]=",i);
scanf("%d",&V[i]);
}
}
//LLENAR EL VECTOR 0 ARREGLO DE FORMA ALEATORIA
void llenar_vector_aleatorio(int V[max]){
int i;
printf("\n");
for(i=0;i<max;i++){
V[i]=rand()%100+1;
printf("[%d]",V[i]);
}
printf("\n");
}
//ORDENAR EL VECTOR ALEATORIO
void ordenar(int A[max]){
int x,y,cont2=0,aux;
for(x=0;x<max-1;x++){
for(y=x+1;y<max;y++){
if(A[x]>A[y]){
aux=A[x];
A[x]=A[y];
A[y]=aux;
cont2=cont2+1;
}}}
printf("El numero de iteraciones de intercambio es:%d\n",cont2);
}
//MOSTRAR EL VECOTR O ARREGLO
void mostrar_vector(int V[max]){
int i;
for(i=0;i<max;i++){
printf("[%d]",V[i]);
}
printf("\n");
}
//PROGRAMA PRINCIPAL
int main(){
int A[max],B[max];
printf("*****************************************\n");
printf("LLENADO MANUAL Y ORDENAMIENTO\n");
llenar_vector(A);
ordenar(A);
mostrar_vector(A);
printf("\n\n*****************************************\n");
printf("LLENADO AUTOMATICO Y ORDENAMIENTO\n");

llenar_vector_aleatorio(B);
ordenar(B);
mostrar_vector(B);
getche();
}
--------------------------------------------------------------------------------2-Construya un programa en C que permita llenar un vector de nmeros reales de 7
elementos por medio del teclado. Finalmente copiar la mitad izquierda del vector en
la derecha y mostrarlo por pantalla.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define L 7
//LLENDADO DEL VECTOR
void llenar_vector(int V[L]){
int i;
for(i=0;i<L;i++){
printf("[%d]=",i);
scanf("%d",&V[i]);
}
printf("\nVector Original\n");
for(i=0;i<L;i++){
printf("[%d]",V[i]);
}
printf("\n");
}
//COPIADO DE LA MITAD IZQUIERDA DEL VECTOR Y COLOCADO EN LA PARTE DERECHA
void mitad_vector(int V[L]){
int i;
for(i=0;i<(L-1)/2;i++){
V[((L-1)/2)+i+1]=V[i];
}
printf("\n");
for(i=0;i<L;i++){
printf("[%d]",V[i]);
}
printf("\n");
}
//PRINCIPAL
int main(){
int A[L];
printf("LLENE EL ARREGLO\n");
llenar_vector(A);
printf("\n******************");
printf("\nEL ARREGLO QUEDO\n");
mitad_vector(A);
getche();
}
--------------------------------------------------------------------------------3-Construya un programa en C que permita determinar cul es el nmero que ms veces
se repite dentro de un vector de nmeros enteros de largo 20. Los valores contenidos
en el vector son ingresados por el usuario.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define L 20
//LLENADO DE LA MATRIZ
void llenar_vector(int V[L]){
int i;
for(i=0;i<L;i++){
printf("[%d]=",i);
scanf("%d",&V[i]);
}

printf("\n");
for(i=0;i<L;i++){
printf("[%d]",V[i]);
}
printf("\n");
}
//BUSCANDO EL NUMERO
void numero(int V[L]){
int i,j,B[L],aux,maximo,C[L];
for(i=0;i<L;i++){
B[i]=1;
for(j=i+1;j<L;j++){
if(V[i]==V[j]){
B[i]=B[i]+1;
C[i]=V[i];
}
}
printf("\nEl numero %d se repite %d veces",V[i],B[i]);
}
maximo=B[0];
for(i=0;i<L;i++){
if(B[i]>maximo){
maximo=B[i];
aux=C[i];
}
}
printf("\n\n\nEl numero que mas se repite es el %d ",aux);
}
//PRINCIPAL
int main(){
int A[L];
printf("LLENADO MANUAL\n");
llenar_vector(A);
numero(A);
getche();
}
--------------------------------------------------------------------------------4-Construya un programa en C que permita llenar una matriz para luego ordenarla en
forma ascendente (menor a mayor) y finalmente determinar cuantas iteraciones fueron
necesarias para lograr el orden.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define F 3
#define C 3
//LLENADO DE LA MATRIZ
void llenar_matriz(int M[F][C]){
int i,j;
for(i=0;i<F;i++){
for(j=0;j<C;j++){
M[i][j]=rand()%15+1;
}
}
printf("\n");
for(i=0;i<F;i++){
for(j=0;j<C;j++){
printf("[%d]",M[i][j]);
}
printf("\n");
}
}
//ORDENAR LA MATRIZ DE MENOR A MAYOR
void ordenar(int M[F][C]){

int x,y,i,j,cont=0,aux;
for(i=0;i<F;i++){
for(j=0;j<C;j++){
for(x=i;x<i+1;x++){
for(y=0;y<C;y++){
if(M[i][j]<M[x][y]){
cont++;
aux=M[i][j];
M[i][j]=M[x][y];
M[x][y]=aux;
}
}
}
}
}
for(i=0;i<F;i++){
for(j=0;j<C;j++){
printf("[%d]",M[i][j]);
}
printf("\n");
}
printf("***********************************************");
printf("\n\nEL NUMERO DE ITERACIONES FUERON:%d",cont);
}
//PRINCIPAL
int main(){
int A[F][C];
printf("INGRESE LOS NUMEROS DE LA MATRIZ");
llenar_matriz(A);
printf("\nLA MATRIZ DE ORDENADA ES\n");
ordenar(A);
getche();
}
--------------------------------------------------------------------------------5-Construya un programa en C que permita contar cuantos nmeros primos existen dentro
de una matriz de 3 x 5. Los valores contenidos en la matriz deben ser generados al
azar.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define F 3
#define C 5
//LLENADO DE LA MATRIZ
void llenar_matriz(int M[F][C]){
int i,j;
for(i=0;i<F;i++){
for(j=0;j<C;j++){
M[i][j]=rand()%15+1;
}
}
printf("\nLA MATRIZ ES\n");
for(i=0;i<F;i++){
for(j=0;j<C;j++){
printf("[%d]",M[i][j]);
}
printf("\n");
}
}
int primos(int M[F][C]){
int i,j,k,primos=0,cont;
for(i=0;i<F;i++){
for(j=0;j<C;j++){
cont=0;

for(k=1;k<=M[i][j];k++){
if(M[i][j]%k==0){
cont=cont+1;
}
}
if(cont==2){
primos++;
}
}
}
return primos;
}
int main(){
int A[F][C];
llenar_matriz(A);
printf("\nLA CANTIDAD DE NUMEROS PRIMOS EN LA MATRIZ ES:%d",primos(A));
getche();
}
--------------------------------------------------------------------------------6-Construya un programa en C que permita llenar una matriz de nmeros enteros de 4
x 5. Finalmente almacenar los primeros n nmeros positivos en un vector de largo
20. Debe validar que n sea como mximo 20. Luego mostrar el contenido del vector.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define F 4
#define C 5
#define L 20
//LLENADO DE LA MATRIZ
void llenar_matriz(int M[F][C]){
int i,j;
for(i=0;i<F;i++){
for(j=0;j<C;j++){
printf("[%d][%d]=",i+1,j+1);
scanf("%d",&M[i][j]);
}
}
printf("\nLA MATRIZ ES\n");
for(i=0;i<F;i++){
for(j=0;j<C;j++){
printf("[%d]",M[i][j]);
}
printf("\n");
}
}
//ALMACENAR LOS PRIMEROS N NUMEROS POSITIVOS EN UN ARREGLO
void almacenar(int M[F][C]){
int i,j,V[L],cont=0;
printf("\nEL VECTOR ES\n");
for(i=0;i<F;i++){
for(j=0;j<C;j++){
if(M[i][j]>0){
cont++;
if(cont<L+1){
V[j]=M[i][j];
printf("[%d]",V[j]);
}
}
}
}
}
//PRINCIPAL

int main(){
int A[F][C];
printf("INGRESE LOS NUMEROS DE LA MATRIZ\n");
llenar_matriz(A);
almacenar(A);
getche();
}
--------------------------------------------------------------------------------7-Construya un programa en C que permita llenar una matriz de N x M y luego copiar
la mitad izquierda de la misma sobre su mitad derecha. Simulando un espejo en su mitad.
//Los comentarios referidos a "cambios", es para cuando el espejo esta de
//forma horizontal (en nuestro caso es vertical)
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define N 3
#define M 5
//LLENADO DE LA MATRIZ
void llenar_matriz(int A[N][M]){
int i,j;
for(i=0;i<N;i++){
for(j=0;j<M;j++){
printf("[%d][%d]=",i+1,j+1);
scanf("%d",&A[i][j]);
}
}
printf("\nLA MATRIZ ORIGINAL\n");
for(i=0;i<N;i++){
for(j=0;j<M;j++){
printf("[%d]",A[i][j]);
}
printf("\n");
}
}
//MATRIZ ESPEJO MITAD VERTICAL
void espejo(int A[N][M]){
int i,j;
//MATRIZ CON N PAR
if(M%2==0){//CAMBIAR M POR N,PARA QUE LA MITAD SUPERIOR SE REFLEJE
// EN LA INFERIOR
for(i=0;i<N;i++){//CAMBIAR N POR (N+1)/2
for(j=0;j<(M+1)/2;j++){//(M+1)/2 POR M
A[i][M-1-j]=A[i][j];//A[I][M-1-J] POR A[N-1-I][J]
}
}
printf("\nLA MATRIZ ESPEJO\n");
for(i=0;i<N;i++){
for(j=0;j<M;j++){
printf("[%d]",A[i][j]);
}
printf("\n");
}
}
//MATRIZ CON N IMPAR (ESTA ES OPCIONAL,SI SE BORRAR EL IF DEL M PAR, EL
//PROGRAMA FUNCIONA IGUAL
if(M%2==1){//CAMBIAR M POR N,PARA QUE LA MITAD SUPERIOR SE REFLEJE
// EN LA INFERIOR
for(i=0;i<N;i++){//CAMBIAR N POR (N-1)/2
for(j=0;j<(M-1)/2;j++){//(M-1)/2 POR M
A[i][M-1-j]=A[i][j];//A[i][M-1-j] POR A[N-1-I][J]
}
}
printf("\nLA MATRIZ ESPEJO\n");

for(i=0;i<N;i++){
for(j=0;j<M;j++){
printf("[%d]",A[i][j]);
}
printf("\n");
}
}
}
//PRINCIPAL
int main(){
int A[N][M];
printf("INGRESE LOS NUMEROS DE LA MATRIZ\n");
llenar_matriz(A);
espejo(A);
getche();
}
--------------------------------------------------------------------------------8-Construya un programa en C que permita invertir todo el contenido de una matriz de
caracteres de orden N x N fila por fila. El contenido de la matriz es ingresado por
el usuario.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define N 4
//LLENADO DE LA MATRIZ
void llenar_matriz(int A[N][N]){
int i,j;
for(i=0;i<N;i++){
for(j=0;j<N;j++){
printf("[%d][%d]=",i+1,j+1);
scanf("%d",&A[i][j]);
}
}
printf("\nLA MATRIZ ORIGINAL\n");
for(i=0;i<N;i++){
for(j=0;j<N;j++){
printf("[%d]",A[i][j]);
}
printf("\n");
}
}
//INVERTIR TODA LA MATRIZ POR FILAS
void invertir_matriz(int A[N][N]){
int i,j,aux1,aux2;
for(i=0;i<(N+1)/2;i++){
for(j=0;j<N;j++){
aux1=A[i][j];
aux2=A[N-1-i][j];
A[N-1-i][j]=aux1;
A[i][j]=aux2;
}
}
printf("\nLA MATRIZ QUEDA\n");
for(i=0;i<N;i++){
for(j=0;j<N;j++){
printf("[%d]",A[i][j]);
}
printf("\n");
}
}
//PRINCIPAL
int main(){
int A[N][N];

printf("INGRESE LOS NUMEROS DE LA MATRIZ\n");

llenar_matriz(A);
invertir_matriz(A);
getche();
}
--------------------------------------------------------------------------------9-Construya un programa en C que permita ingresar la siguiente informacin de 30
alumnos. Nombre, Promedio, Carrera. Finalmente mostrar el nombre de todos los
reprobados y Carrera de todos los aprobados en el mismo orden solicitado.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define L 30
//no se ejecuta como corresponde, es mejor hacerlo por estructuras
//INGRESAR LOS DATOS(NOMBRE, PROMEDIO,CARRERA)
void ingresar_datos(int V[L]){
char nombre[L],carrera[L];
float promedio[L],x;
int i;
printf("INGRESE NOMBRE,PROMEDIO Y CARRERA DEL ALUMNO\n");
for(i=0;i<L;i++){
printf("Nombre:");
scanf("%s",&nombre[i]);
printf("Promedio:");
scanf("%f",&promedio[i]);
printf("Carrera:");
scanf("%s",&carrera[i]);
printf("\n");
}
printf("\nLos alumnos reprobados son:");
for(i=0;i<L;i++){
if(promedio[i]<4){
printf("\n[%s]",nombre[i]);
}
}
printf("\nLos listado de carreras aprobadas son:");
for(i=0;i<L;i++){
if(promedio[i]>=4){
printf("\n[%s]",carrera[i]);
}
}
}
int main(){
int A[L];
ingresar_datos(A);
getche();
}
--------------------------------------------------------------------------------10-Construya un programa en C que permita resolver lo siguiente considerando una matriz
de nmeros enteros de MAX x MAX. Para cada M(i,j):
Si M (i, j) Es par --> M(i,j)=M(i,j)*3
Es Impar--> M(i,j)=M(i,j)*2
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define max 3
//LLENAR MATRIZ
void llenar_matriz(int A[max][max]){
int i,j;
for(i=0;i<max;i++){
for(j=0;j<max;j++){
printf("[%d][%d]=",i+1,j+1);
scanf("%d",&A[i][j]);

}
}
printf("\nLA MATRIZ ORIGINAL\n");
for(i=0;i<max;i++){
for(j=0;j<max;j++){
printf("[%d]",A[i][j]);
}
printf("\n");
}
}
//MULTIPLICAR CIERTOS COEFICIENTES POR UN ESCALAR
void escalar(int A[max][max]){
int i,j;
for(i=0;i<max;i++){
for(j=0;j<max;j++){
if(A[i][j]%2==0){
A[i][j]=A[i][j]*3;
}
if(A[i][j]%2==1){
A[i][j]=A[i][j]*2;
}
}
}
printf("\nLA MATRIZ MODIFICADA\n");
for(i=0;i<max;i++){
for(j=0;j<max;j++){
printf("[%d]",A[i][j]);
}
printf("\n");
}
}
//PRINCIPAL
int main(){
int A[max][max];
printf("\nINGRESE LOS NUMEROS\n");
llenar_matriz(A);
escalar(A);
getche();
}
--------------------------------------------------------------------------------11-Determine si una matriz de nmeros enteros llenada por el usuario es una matriz
Nula. Una matriz es nula si todos sus elementos son cero.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define N 3
#define M 3
//LLENAR MATRIZ
void llenar_matriz(int A[N][M]){
int i,j;
for(i=0;i<N;i++){
for(j=0;j<M;j++){
printf("[%d][%d]=",i+1,j+1);
scanf("%d",&A[i][j]);
}
}
printf("\nLA MATRIZ ORIGINAL\n");
for(i=0;i<N;i++){
for(j=0;j<M;j++){
printf("[%d]",A[i][j]);
}
printf("\n");
}

}
//VERIFICAR SI LA MATRIZ LLENADA ES NULA
void verificar(int A[N][M]){
int i,j,cont=0;
for(i=0;i<N;i++){
for(j=0;j<M;j++){
if(A[i][j]==0){
cont++;
}
}
}
if(cont==N*M){
printf("LA MATRIZ ES UNA MATRIZ NULA");
}
else{
printf("LA MATRIZ ES UNA MATRIZ NO NULA");
}
}
//PRINCIPAL
int main(){
int A[N][M];
printf("\nINGRESE LOS NUMEROS\n");
llenar_matriz(A);
verificar(A);
getche();
}
--------------------------------------------------------------------------------12-Construya un programa en C que muestre por pantalla la matriz transpuesta de una
ingresada por el usuario.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define N 3
#define M 3
//MATRIZ TRANSPUESTA
void transpuesta(int A[N][M]){
int i,j;
for(i=0;i<N;i++){
for(j=0;j<M;j++){
printf("[%d][%d]=",i+1,j+1);scanf("%d",&A[i][j]);
}
}
printf("\nLA MATRIZ ORIGINAL\n");
for(i=0;i<N;i++){
for(j=0;j<M;j++){
printf("[%d]",A[i][j]);
}
printf("\n");
}
printf("\nLA MATRIZ TRANSPUESTA\n");
for(j=0;j<M;j++){
for(i=0;i<N;i++){
printf("[%d]",A[i][j]);
}
printf("\n");
}
}
//PRINCIPAL
int main(){
int A[N][M];printf("INGRESE LOS NUMEROS\n");
transpuesta(A);
getche();
}

--------------------------------------------------------------------------------13-Se tiene una matriz cuadrada de orden N, compuesta por 1s y 0s, la cual representa
una letra escaneada desde un texto, un 1 en la matriz representa escritura y un 0,
no escritura. Se pide codifique una funcin en C que permita determinar si la letra
representada en la matriz es una H.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define N 3
//LLENADO DEL VECTOR
void llenar_matriz(int A[N][N]){
int i,j;
for(i=0;i<N;i++){
for(j=0;j<N;j++){
printf("[%d][%d]=",i+1,j+1);
scanf("%d",&A[i][j]);
}
}
printf("\nLA MATRIZ ORIGINAL\n");
for(i=0;i<N;i++){
for(j=0;j<N;j++){
printf("[%d]",A[i][j]);
}
printf("\n");
}
}
//VERIFICACION DE QUE LA MATRIZ FORMA LA LETRA H
void verificar(int A[N][N]){
int i,j,cont1=0,cont2=0,cont3=0,cont4=0,unos,ceros;
for(i=0;i<N;i++){
if(A[i][0]==1 && A[i][N-1]==1){
cont1=cont1+2;
}
}
for(j=1;j<N-1;j++){
if(A[(N-1)/2][j]==1){
cont2=cont2+1;
}
}
for(i=0;i<(N-1)/2;i++){
for(j=1;j<N-1;j++){
if(A[i][j]==0){
cont3=cont3+1;
}
}
}
for(i=(N+1)/2;i<=N;i++){
for(j=1;j<N-1;j++){
if(A[i][j]==0){
cont4=cont4+1;
}
}
}
unos=cont1+cont2;
ceros=cont3+cont4;
if(unos==(3*N-2) && ceros==(N*N-3*N+2)){
printf("\nLA MATRIZ FORMA LA LETRA H");
}
else{
printf("\nLA MATRIZ --NO-- FORMA LA LETRA H");
}
}

//PRINCIPAL
int main(){
int A[N][N];
printf("LLENE LA MATRIZ\n");
llenar_matriz(A);
verificar(A);
getche();
}
--------------------------------------------------------------------------------14-Una agencia de venta de vehculos distribuye 15 modelos diferentes y tiene en su
plantilla 10 vendedores. Se desea un programa que escriba un informe mensual de las
ventas por vendedor y modelo, as como el nmero de automviles vendidos por cada
vendedor y el nmero total de cada modelo vendido por todos los vendedores. Asimismo,
para entregar el premio al mejor vendedor, se necesita saber cul es el vendedor que
ms coches ha vendido.
/*Este programa no se ejecuta como corresponde.... de todas formas lo adjunto,
para dar una idea aproximada de como deberia ser. Este tipo de problemas es
mejor resolverlo por estructuras.*/
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
int main(){
int i,a,x,cont,suma,Total,maximo,;
int Mvendido,ventas[10],Modelos[15],Autos[50];
char b,Vendedor[10],mejor;
cont=0;
Total=0;
for(x=1;x<=15;x++){
Modelos[x]=x;
}
for(x=1;x<=15;x++){
Autos[x]=0;
}
for(i=0;i<10;i++){
printf("\nNombre del vendedor:");scanf("&s",&Vendedor[i]);
printf("\nCuantos autos fueron vendidos por el?:");scanf("%d",&ventas[i]);
a=ventas[i];
Total=Total+a;
if(a>0){
printf("\nModelo vendido(entre 1 y 15):");
scanf("%d",&Mvendido);
for(x=1;x<=15;x++){
if(Modelos[x]==Mvendido){
Autos[x]=Autos[x]+1;
}
}
}
}
maximo=ventas[0];
for(i=0;i<10;i++){
if(ventas[i]>maximo){
maximo=ventas[i];
mejor=Vendedor[i];
}
}
for(i=0;i<10;i++){
b=Vendedor[i];
a=ventas[i];
printf("\nNombre del vendedor: %s",b);
printf("\nAutos vendidos por el: %d",a);
}

printf("\n\nLa cantidad de autos vendidos son %d",Total);

printf("\nEl premio al mejor vendedor es para %s",mejor);
getche();
}
--------------------------------------------------------------------------------15-Una matriz cuadrada de orden N es diagonal dominante si cumple que

| | > | |, , = 1,2,3 .

Escriba una funcin que permita imprimir un mensaje adecuado si una matriz dada como
parmetro es diagonal dominante o no.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define N 3
//LLENAR MATRIZ
void llenar_matriz(int A[N][N]){
int i,j;
for(i=0;i<N;i++){
for(j=0;j<N;j++){
printf("[%d][%d]=",i+1,j+1);scanf("%d",&A[i][j]);
}
}
printf("\nLA MATRIZ ORIGINAL\n");
for(i=0;i<N;i++){
for(j=0;j<N;j++){
printf("[%d]",A[i][j]);
}
printf("\n");
}
}
//VERIFICAR SI LA MATRIZ ES DIAGONAL DOMINANTE
int diagonal_dominante(int A[N][N]){
int i,j,suma,cont;
cont=0;
for(i=0;i<N;i++){
suma=0;
for(j=0;j<N;j++){
if(i!=j){
suma=suma+abs(A[i][j]);
}
}
if(abs(A[i][i]) > suma){
cont++;
}
}
if(cont==N){
printf("\nLA MATRIZ ES DIAGONAL DOMINANTE");
}
else{
printf("\nLA MATRIZ NO ES DIAGONAL DOMINANTE");
}
}
//PRINCIPAL
int main(){
int A[N][N];
printf("INGRESE LOS NUMEROS\n");
llenar_matriz(A);
diagonal_dominante(A);
getche();
}

--------------------------------------------------------------------------------16-Cuando el 80% o ms de los elementos de una matriz cuadrada de orden N es nulo,

entonces la matriz se denomina esparse (o matriz rala). Escriba una funcin que
permita retornar un 1 si una matriz dada es esparse, un 0 sino.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define N 3
//LLENADO DEL VECTOR
void llenar_matriz(int A[N][N]){
int i,j,suma=0;
for(i=0;i<N;i++){
for(j=0;j<N;j++){
printf("[%d][%d]=",i+1,j+1);
scanf("%d",&A[i][j]);
}
}
printf("\nLA MATRIZ ORIGINAL\n");
for(i=0;i<N;i++){
for(j=0;j<N;j++){
printf("[%d]",A[i][j]);
}
printf("\n");
}
}
//VERIFICACION SI UNA MATRIZ ES RALA O NO
int matriz_rala(int A[N][N]){
int i,j,cont,x,p;
float y;
cont=0;
for(i=0;i<N;i++){
for(j=0;j<N;j++){
if(A[i][j]==0){
cont=cont+1;
}
}
}
x=(int)N*N*0.8;
y=(float)N*N*0.8;
if((y-x)<0.5){
p=x;
}
else{
p=x+1;
}
if(cont>=p){
printf("\nLA MATRIZ ES ESPARCE O RALA");
return 1;
}
else if(cont<p){
printf("\nLA MATRIZ--NO--ES ESPARCE O RALA");
return 0;
}
}
//PRINCIPAL
int main(){
int A[N][N];
printf("LLENE LA MATRIZ\n");
llenar_matriz(A);
printf("\n\nLA MATRIZ ES %d [1=esparse,0=no esparse]",matriz_rala(A));
getche();
}
---------------------------------------------------------------------------------


, A es invertible ssi det(A)0. Si existe, se puede

calcular como = ()
. Escriba una funcin que permita calcular y mostrar

la inversa de una matriz si es que ella existe, o un mensaje apropiado en caso de no
existir.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define N 2
//LLENADO DEL VECTOR
void llenar_matriz(int A[N][N]){
int i,j,suma=0;
for(i=0;i<N;i++){
for(j=0;j<N;j++){
printf("[%d][%d]=",i+1,j+1);
scanf("%d",&A[i][j]);
}
}
printf("\nLA MATRIZ ORIGINAL\n");
for(i=0;i<N;i++){
for(j=0;j<N;j++){
printf("[%d]",A[i][j]);
}
printf("\n");
}
}
//SACAR EL DETERMINANTE DE LA MATRIZ 2X2
float determinante(int A[N][N]){
int i,j,det;
det=A[0][0]*A[1][1]-A[0][1]*A[1][0];
return det;
}
//INVERTIR LA MATRIZ
void inversa(int A[N][N]){
float B[N][N];
int i,j;
if(determinante(A)!=0){
B[0][0]=A[1][1]/determinante(A);
B[0][1]=-1*A[0][1]/determinante(A);
B[1][0]=-1*A[1][0]/determinante(A);
B[1][1]=A[0][0]/determinante(A);
for(i=0;i<N;i++){
for(j=0;j<N;j++){
printf("[%f]",B[i][j]);
}
printf("\n");
}
}
if(determinante(A)==0){
printf("LA MATRIZ INVERSA NO EXISTE");
}
}
//PRINCIPAL
int main(){
int A[N][N];
printf("LLENE LA MATRIZ\n");
llenar_matriz(A);
determinante(A);
printf("\nLA MATRIZ INVERSA ES\n");
inversa(A);
getche();
}
--------------------------------------------------------------------------------17-Dada una matriz A, =