Ejercicios Con Matrices

  1. Mostrar la diagonal principal. ( Solo las matrices cuadradas tienen diagonales).
  2. Mostrar la diagonal secundaria. 
  3. Mostrar triángulo superior según la diagonal principal – EXCLUYENDO LA DIAGONAL.
  4. Mostrar triángulo inferior según la diagonal principal – EXCLUYENDO LA DIAGONAL.
  5. Mostrar triángulo superior según la diagonal principal – INCLUYENDO LA DIAGONAL.
  6. Mostrar triángulo inferior según la diagonal principal – INCLUYENDO LA DIAGONAL.
  7. Mostrar triángulo superior según la diagonal secundaria – EXCLUYENDO LA DIAGONAL.
  8. Mostrar triángulo inferior según la diagonal secundaria – EXCLUYENDO LA DIAGONAL.
  9. Mostrar triángulo superior según la diagonal secundaria – INCLUYENDO LA DIAGONAL.
  10. Mostrar triángulo inferior según la diagonal secundaria – INCLUYENDO LA DIAGONAL.
  11. Mostrar ambos triángulos al mismo tiempo según diagonal principal.
  12. Mostrar ambos triángulos al mismo tiempo según diagonal secundaria.
  13. Mostrar cada uno de los siguientes triángulos por separado – EXCLUYENDO LAS DIAGONALES.
  1. Ídem que el anterior, pero INCLUYENDO LAS DIAGONALES (es decir el triángulo con sus porciones de la diagonal, no toda la diagonal).
  2. Trasponer la matriz según la diagonal principal.
  3. Trasponer la matriz según la diagonal secundaria.
  4. Trasponer la matriz a 90° horizontalmente.
  5. Trasponer la matriz a 90° verticalmente. 
  6. Trasponer la matriz según el centro.
  7. ¿Es la matriz simétrica?
  8. ¿Es la matriz identidad?
  9. Producto de matrices!! MUY IMPORTANTE
  10. Dado un i, j > mostrar todos los vecinos de ese i, j (el máximo es hasta 8 vecinos).
  11. Dado un i, j > mostrar la mayor matriz que tenga a ese i, j de vértice.
  1. (i, j) Inferior izquierdo.
  2. (i, j) Inferior derecho.
  3. (i, j) Superior izquierdo.
  4. (i, j) Superior derecho.
  1. Dado un i, j > mostrar la mayor matriz CUADRADA que tenga a ese i, j de vértice.
  2. Dado un i, j > mostrar la menor matriz que tenga a ese i, j de vértice.
  3. Dado un i, j > mostrar la menor matriz CUADRADA que tenga a ese i, j de vértice.
  4. Mostrar la matriz en espiral.

Diagonal Principal: 

int main()
{
    int mat[4][4]= {{1,2,3,4},{5,6,7,8}, {9,10,11,12},{13,14,15,16}};
    int sumaDP = sumDiagonalPrincipal(mat);
    printf("La suma de la diagonal principal es: %d \n", sumaDP);

    return 0;
}


int sumDiagonalPrincipal(int mat[][4])
{
 int sumaDP=0;
 for (int i=0; i<=3; i++)
       sumaDP += mat[i][i];
 return sumaDP;
}

Diagonal Principal para que acepte otras matrices que no sean 4 x 4

int sumDiagonalPrincipal(int cols, int mat[][cols]);

int main()
{
    int mat[4][4]= {{1,2,3,4},{5,6,7,8}, {9,10,11,12},{13,14,15,16}};
    int sumaDP = sumDiagonalPrincipal(4,mat);
    printf("La suma de la diagonal principal es: %d \n", sumaDP);

    return 0;
}


int sumDiagonalPrincipal(int cols, int mat[][cols])
{
 int sumaDP=0;
 for (int i=0; i<cols; i++)
       sumaDP += mat[i][i];
 return sumaDP;
}

Triangulo Inferior sin diagonal principal

int sumarTriangInf(int cols, int mat[][cols])
{
 int sum = 0;
 for (int i=1 ; i< cols; i++)
    for(int j=0;j<i;j++)
        sum+= mat[i][j];

 return sum;
}

Triangulo Superior sin diagonal principal

int sumarTriangSup(int cols, int mat[][cols])
{
 int sum = 0;
 for (int i=0 ; i< cols-1; i++)
    for(int j=i+1 ;j< cols;j++)
        sum+= mat[i][j];

 return sum;
}

Diagonal Secundaria

Debo buscar alguna forma en que se relacionan i y j. La idea es realizarlo con un solo for. 

int sumarDiagSec(int cols, int mat[][cols])
{
 int sum = 0;
 for (int i=0 ; i< cols; i++)
        sum+= mat[i][cols-1-i];

 return sum;
}

Suma triangulo Superior Respecto de la Diagonal Secundaria

int sumTriangSuperRespectoDiagSec(int cols, int mat[][cols])
{
    int suma=0;
    for (int i=0; i<cols; i++)
        for(int j=0; j<cols-1-i; j++)
            suma += mat[i][j];
    return suma;
}

Producto de Matrices

Para matrices no cuadradas, por ejemplo tengo una matriz de 2×4 y una 4×3. Las columnas de la primer matriz debe ser la misma cantidad de filas de la matriz 2.

#include <stdio.h>
#include <stdlib.h>

void ** crearMatriz ( size_t cantFilas, size_t cantColumnas, size_t tamElem);
void destruirMatriz ( void** mat, size_t filas);
void cargarMatriz (int ** mat, size_t filas, size_t columnas);
void cargarMatriz2 (int ** mat, size_t filas, size_t columnas);
void mostrarMatriz (int ** mat, size_t filas, size_t columnas);
int  ** productoMatrices(int** m1, int** m2, int filM1, int colM1filM2, int colM2);


int main()
{
    int filas = 2;
    int filas2 = 4;
    int columnas =4;
    int columnas2 =3;
    int ** matriz = (int**)crearMatriz(filas, columnas, sizeof(int));
    int ** matriz2 = (int**)crearMatriz(filas2, columnas2, sizeof(int));
    if(!matriz)
    {
        puts("Sin Memoria");
        return 0;
    }

    if(!matriz2)
    {
        puts("Sin Memoria");
        return 0;
    }

    cargarMatriz(matriz,filas,columnas);
    cargarMatriz2(matriz2,filas2,columnas2);
    mostrarMatriz(matriz,filas,columnas);
    printf("\n");
    mostrarMatriz(matriz2,filas2,columnas2);


    int **matrizResult = productoMatrices(matriz,matriz2,filas,columnas,columnas2);
    printf("\n");
    mostrarMatriz(matrizResult,filas,columnas2);

    destruirMatriz((void**)matriz, filas);
    destruirMatriz((void**)matriz2, filas2);
    destruirMatriz((void**)matrizResult,filas);
    return 0;

}



void ** crearMatriz ( size_t cantFilas, size_t cantColumnas, size_t tamElem)
{
    //tamElem esta en bytes
    void ** mat = malloc ( cantFilas * sizeof(void*));
    // reservo memoria para todas los punteros a void de filas.
    if(!mat)
    {
        return NULL;
    }
    void **ult = mat + cantFilas -1;
    for (void ** i = mat; i<=ult; i++)
    {
        *i = malloc(cantColumnas * tamElem);
        if(!*i)
        {
            for(void** j=mat; j<i; j++)
            {
                free(*j);
            }
            free(mat); // si hago solo free de mat libera la primer columna y el resto no.
            return NULL;
        }

    }
    return mat;
}


void destruirMatriz ( void** mat, size_t filas)
{
    void** ult = mat + (filas -1);
    for( void ** i = mat ; i<=ult; i++)
        free(*i);
    free(mat);
}



void cargarMatriz (int ** mat, size_t filas, size_t columnas)
{
    for(int i = 0; i <filas; i++)
        for(int j=0; j<columnas; j++)
            mat[i][j]=i*4+j+1;

}

void cargarMatriz2 (int ** mat2, size_t filas2, size_t columnas2)
{
    for(int i = 0; i <filas2; i++)
        for(int j=0; j<columnas2; j++)
            mat2[i][j]=i*3+j+1;

}

void mostrarMatriz (int ** mat, size_t filas, size_t columnas)
{
    for(int i = 0; i <filas; i++)
    {
        for(int j=0; j<columnas; j++)
            printf("%d \t", mat[i][j]);
        printf("\n");
    }
}


int  ** productoMatrices(int** m1, int** m2, int filM1, int colM1filM2, int colM2)
{
    int** matrizResult = (int**)crearMatriz(filM1, colM2, sizeof(int));
    if(!matrizResult)
        return NULL;

    for (int i= 0; i< filM1 ; i++)
    {
        for (int j= 0; j< colM2; j++)
        {
            matrizResult[i][j]=0;
            for (int k=0; k< colM1filM2; k++)
                matrizResult[i][j]+= m1[i][k]*m2[k][j];
        }
    }


    return matrizResult;
}