/*

Exerccio
Fazer uma funcao que recebe 2 matrizes, de tamanho N e M, realizar, se possvel, a
multiplicacao das mesmas
(if possible), mostrando o resultado na nova matriz na tela e seu determinante.
Caso no seja possvel, a
sada da funo deve retomar a ordem das matrizes. M e N tem tamanho mximo de 3.
*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#define TAM 3 //<-- Restringe o tamanho mximo de linhas e colunas :(
#define MAT 2//<-- Restringe a quantidade de matrizes inseridas<-- SE AUMENTAR O
U DIMINUIR UMA DIMENSAO, DEVERAS AUMETAR OU DIMINUIR UM PONTEIRO Ex: se MAT rece
be 3, teriamos p***, logo, necessitariamos de mais um loop para enderecar o ulti
mo elemento. Pode-se pensar que p*** eh um ponteiro que aponta para um ponteiro,
que aponta para um ponteiro que aponta para um endereco. Eu acho que esse topic
os se chama arrays de ponteiro ou algo assim.

void Receber_Lin_e_Col(int dim1[], int dim2[], int ordem[], int *, int *);
void Armazenar_Ordens(int dim1[], int dim2[], int ordem[], int *);
void Verificar_Lin_e_Col(int dim1[], int dim2[], int ordem[]);
int Gerar_Random_2D(int **, int, int );
void Imprimir_Matriz(int **, int, int );
void Multiplicar_Matrizes(int **, int **, int **, int, int, int*);
void Zerar_Multi(int **, int , int);
void Determinante(int **, int , int);
int main(void) {
char opt1, opt2='s';
int dim1[MAT], dim2[MAT], ordem[MAT], i,j=0, k=0, x=0;
int **p;
int **l;
int **m;
int verificaMulti =0;
int passo;
int *ptr_verificaMulti =&passo;
int *ptr_passo = &passo;
srand(time(NULL));
printf("----------------------------------------------------------------
--------\n\n");
while(opt2=='s') {
printf("\nESTE PROGRAMA CRIA DUAS MATRIZ COM VALORES INTEIROS RANDOMICOS
DE MxN DIMENSES DEFINIDAS PELO USUARIO E OFERECE OPCOES:\n");
printf("Deseja iniciar (s ou n)?\n");
scanf("%c",&opt1);
scanf("%*c");
if (opt1 == 'y' || opt1 =='s') {
Receber_Lin_e_Col(dim1,dim2, ordem, ptr_passo, ptr_verif
icaMulti);
Verificar_Lin_e_Col(dim1,dim2, ordem);
//Inicio - Alocando a matriz dinamicamente
//Matriz 1
p= (int**) malloc(dim1[0]*sizeof(int*)); //repare nos *
- acabamos de alocar o espao para as linhas da matriz 1
 if (!p) {
printf("\n** Erro: Memoria Insuficiente **\n");
exit(0);
}
for (i=0;i<dim1[0];i++) {
p[i]= (int *) malloc(dim2[0]*sizeof(int));// ago
ra alocamos o espao para as colunas da matriz 1
j++;
if (!p[i]) {
printf("\n** Erro: Memoria Insuficiente
**\n");
for(i=0;i<j;i++) {
free(p[i]);
}
free(p);
exit(0);
}
}
//Matriz 2
l=(int**) malloc(dim1[1]*sizeof(int*));//acabamos de alo
car o espao para as linhas da matriz 2
if (!l) {
printf("\n** Erro: Memoria Insuficiente **\n");
exit(0);
}
for (i=0;i<dim1[1];i++) {
l[i]= (int*) malloc(dim2[1]*sizeof(int));// agor
a alocamos o espao para as colunas da matriz 2
k++;
if (!l[i]) {
printf("\n** Erro: Memoria Insuficiente
**\n");
for (i=0;i<k;i++) {
free(l[i]);
}
free(l);
exit(0);
}
}
Gerar_Random_2D(p, dim1[0], dim2[0]);
Gerar_Random_2D(l, dim1[1], dim2[1]);
getchar();
printf("\nMatriz 1:\n");
Imprimir_Matriz(p, dim1[0], dim2[0]);
getchar();
printf("\nMatriz 2:\n");
Imprimir_Matriz(l, dim1[1], dim2[1]);
//Abaixo - se a variavel verificaMulti for verdadeira al
ocaremos a matriz que receber a nova matriz - observe como eh um inferno desaloca
r a memoria..
if (*ptr_verificaMulti) {
m=( int**) malloc(dim1[0]*sizeof(int*));
if (!m) {
printf("\n** Erro: Memoria Insuficiente
**\n");
for(i=0;i<j;i++) {
free(p[i]);
}
for (i=0;i<k;i++) {
free(l[i]);
 }
free(p);
free(l);
exit(0);
}
for (i=0;i<dim1[0];i++) {
m[i]= (int*) malloc(dim2[1]*sizeof(int))
;
x++;
if (!m[i]) {
printf("\n** Erro: Memoria Insuf
iciente **\n");
for(i=0;i<j;i++) {
free(p[i]);
}
for (i=0;i<k;i++) {
free(l[i]);
}
for (i=0;i<x;i++) {
free(m[i]);
}
free(p);
free(l);
free(m);
exit(0);
}
}
Zerar_Multi(m, dim1[0],dim2[1]);
//erro
Multiplicar_Matrizes(p,l,m, dim1[0],dim2[1], ptr
_passo);
printf("\nA matriz resultande da multiplicao eh:
\n");
getchar();
Imprimir_Matriz(m, dim1[0], dim2[1]);
}else {
printf("\nNao eh possivel realizar a multiplicao
:(\n\n");
Verificar_Lin_e_Col(dim1,dim2, ordem);
}
Determinante(m, dim1[0], dim2[1]);
}
printf(" \nPara repetir, digite a lecla s\n");
scanf("%c",&opt2);
scanf("%*c");
}
for(i=0;i<j;i++) {
free(p[i]);
}
for (i=0;i<k;i++) {
free(l[i]);
}
for (i=0;i<x;i++) {
free(m[i]);
}
free(p);
free(l);
free(m);
exit(0);
}
void Armazenar_Ordens(int dim1[2], int dim2[2], int ordem[2], int* passo) {
int i;
for (i=0;i<2;i++) {
ordem[i]=dim1[i]*dim2[i];
}
if (ordem[0]<ordem[1]) {
*passo = dim2[1];
}if (ordem[0]>ordem[1]) {
*passo = dim1[0];
}else {
*passo = dim1[0];
}
}
void Receber_Lin_e_Col(int dim1[2], int dim2[2], int ordem[2], int* passo, int*
verificaMulti ) {
int i;
for (i=0;i<2;i++) {
printf("Insira a quantidade de linhas da matriz %d: \n", i+1);
scanf("%d",&dim1[i]);
scanf("%*c");
printf("Insira a quantidade de colunas da matriz %d: \n", i+1);
scanf("%d",&dim2[i]);
scanf("%*c");
}
if (dim1[1]==dim2[0]) {//<-- Verifica se eh possivel multiplicar
*verificaMulti =1;
}else {
*verificaMulti =0;
}
Armazenar_Ordens(dim1,dim2, ordem, passo);
}

void Verificar_Lin_e_Col(int dim1[2], int dim2[2], int ordem[2]) {

int i;
for (i=0;i<2;i++) {
if (dim1[i] >3 || dim2[i] > 3) {
printf("Quantidade de linhas ou colunas superior ao perm
itido.\nMatriz %d: %dx%d - Ordem: %d.\n",i+1,dim1[i],dim2[i], ordem[i]);
exit(0);
}else
printf("\nMatriz %d: %dx%d- Ordem: %d.\n",i+1, dim1[i],
dim2[i], ordem[i]);
}
}
int Gerar_Random_2D(int **vet, int dim1, int dim2){
int i, j, x, y, k;
for (i=0;i<dim1;i++){
for (j=0;j<dim2;j++){
k=0;
 vet[i][j]=rand()%(dim1*dim2);
//printf("\n1 tentativa - Elemento vet[%d][%d]: %d",i,j,
vet[i][j]);//Teste1
if (i>0||j>0) {
for (x=0;x<dim1;x++) {
for (y=0;y<dim2;y++) {
while (vet[x][y]==vet[i][j]) {
if (x==i && y==j){
break;
}else {
//printf("\nElem
ento repetido: vet[%d][%d]: %d | vet[%d][%d]: %d",i,j,vet[i][j],x,y, vet[x][y]);
//Teste1
vet[i][j]=rand()
%(dim1*dim2)+1;
k++;
//printf("\n%d t
entativa - Elemento vet[%d][%d]: %d",k+1,i,j,vet[i][j]);//Teste1
x=y=0;
if (k>200) {
return(0
);
}
}
}
}
}
}
}
}
}
void Imprimir_Matriz(int **p, int dim1, int dim2){
int i, j;
for (i=0;i<dim1;i++) {
for (j=0;j<dim2;j++) {
printf(" %d ", p[i][j]);
}
printf("\n");
}
}
void Zerar_Multi(int **m, int dim1, int dim2){
int i, j;
for (i=0;i<dim1;i++) {
for (j=0;j<dim2;j++) {
m[i][j]=0;
}
}
}
void Multiplicar_Matrizes(int **p, int **l, int **m, int dim1, int dim2, int* pa
sso) {
int i, j, k;
for (i=0;i<dim1;i++) {
for (j=0;j<dim2;j++) {
for (k=0;k<*passo;k++) {
 m[i][j]=p[i][k]*l[k][j]+m[i][j];//ptr3[i*dim1+j]
=p[i*dim1+k]*l[k*dim2+j]+ptr3[i*dim1+j];
//printf(" %dx%d ", p[i][k],l[k][j]);// <-- Test
e - imprime quais elementos estao se multiplicando
}
//printf("a%dx%d = %d ", i+1,j+1,m[i][j]); //<-- Teste -
imprime elemento a elemento
}
//printf("\n"); //<-- Teste
}
}
void Determinante(int **m, int dim1 , int dim2) {
long int det;
printf("\nIniciando calculo do determinante...\n. ");
if (dim1!=dim2) {
printf("\nA matriz nao eh quadrada.\n");
}else {
if (dim1 == 1) {
printf("\nMatriz 1x1. O determinante eh: %d.\n", m[0][0]
);
}if (dim1 == 2) {
det=m[0][0]*m[1][1]-m[0][1]*m[1][0];
printf("\nMatriz 2x2. O determinante eh: %ld.\n", det);
}if (dim1 == 3) {
det=m[0][0]*m[1][1]*m[2][2]+m[0][1]*m[1][2]*m[2][0]+m[0]
[2]*m[1][0]*m[2][1]-(m[2][0]*m[1][1]*m[0][2]+m[2][1]*m[1][2]*m[0][0]+m[2][2]*m[1
][0]*m[0][1]);
printf("\nMatriz 3x3. O determinante eh: %ld.\n",det);
}
}
}