menuMatrices

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <iomanip>
#include <map>

#define SALTO std::cout << std::endl << std::endl

typedef struct {
    int **mat = NULL;
    int m;
    int n;

}Matrix;

void create(Matrix&);
void fillMatrix(Matrix); //int **, int, int);
void printMatrix(Matrix);
void destroy(Matrix&);
void newMatrix(Matrix&); //int**&, int**&, int&, int&);
int menu(Matrix);
bool runOptions(int, Matrix&);

void intercambiarColumnas(Matrix);
void intercambiarFilas(Matrix);
void transponerFilaCol(Matrix);
void sumaDiagonales(Matrix);
void transponerDiagonalFila(Matrix);
void reemplazarConCinco(Matrix);
void promedioReemplazar(Matrix);
void sumaLetraO(Matrix);
void promedioLetraL(Matrix);
void reemplazarLetraU(Matrix);

int main()
{
    Matrix m;

    while( runOptions(menu(m), m) );

    destroy(m);

    return 0;
}

int menu(Matrix m){
    std::map<int, std::string> opciones{ {0, "Crear una matriz"},
                                         {1, "Intercambiar columnas: primera y ultima (mxn)"},
                                         {2, "Intercambiar filas: primera y ultima (mxn)"},
                                         {3, "Intercambiar primera columna con ultima fila (nxn)"},
                                         {4, "Suma diagonales: principal y secundaria (nxn)"},
                                         {5, "Intercambiar diagonal principal por ultima fila (nxn)"},
                                         {6, "Reemplazar diagonal secundaria con 5's (nxn)"},
                                         {7, "Promedio de los numeros pares. Numero mayor y reemplazo de valores (mxn)"},
                                         {8, "Sumar numeros que forman la letra O (mxn)"},
                                         {9, "Promedio de numeros que forman letra L (mxn)"},
                                         {10, "Reemplazar por 0 los numeros letra U (mxn)"},
                                         {11, "Salir"} };
    int opc;

    std::cout << "  M  E  N  U" << std::endl << std::endl;

    for(const auto &i: opciones)
            std::cout << ( (m.mat==NULL && i.first!=0 && i.first!=(opciones.size()-1) ||
                         (i.first>=3 && i.first<=6 && m.m!=m.n) ) ?"*":" ")
                      << std::setw(2) << i.first << ". " << i.second << std::endl;

    std::cout << std::endl;

    if( m.mat==NULL || m.m!=m.n )
        std::cout << "* Ninguna de estas opciones esta disponible por el momento." << std::endl << std::endl;

    do{
        std::cout << "Opcion: ";
        std::cin >> opc;
    }while( opc<0 || opc>=opciones.size() );

    return opc;
}

bool runOptions(int opc, Matrix &m){
    bool state = true;

    system("cls");

    switch (opc){
        case 0:
            newMatrix(m);
            fillMatrix(m);
            break;
        case 1:
            if( m.mat!=NULL )
                intercambiarColumnas(m);
            break;
        case 2:
            if( m.mat!=NULL )
                intercambiarFilas(m);
            break;
        case 3:
            if( m.mat!=NULL && m.m==m.n )
                transponerFilaCol(m);
            break;
        case 4:
            if( m.mat!=NULL && m.m==m.n )
                sumaDiagonales(m);
            break;
        case 5:
            if( m.mat!=NULL && m.m==m.n )
                transponerDiagonalFila(m);
            break;
        case 6:
            if( m.mat!=NULL && m.m==m.n )
                reemplazarConCinco(m);
            break;
        case 7:
            if( m.mat!=NULL )
                promedioReemplazar(m);
            break;
        case 8:
            if( m.mat!=NULL )
                sumaLetraO(m);
            break;
        case 9:
            if( m.mat!=NULL )
                promedioLetraL(m);
            break;
        case 10:
            if( m.mat!=NULL )
                reemplazarLetraU(m);
            break;
        case 11:
            state = false;
            break;
    }

    SALTO;
    if( opc!=11 )
        system("pause");

    system("cls");

    return state;
}

void newMatrix(Matrix &m){ //int**& mat0, int**& mat1, int& m, int& n){
    if( m.mat!=NULL )
        destroy(m);

    do{
        system("cls");
        std::cout << "MATRIZ NUEVA";
        SALTO;
        std::cout << "Cuantas filas deseas? ";
        std::cin >> m.m;
        std::cout << "Cuantas columnas deseas? ";
        std::cin >> m.n;

        if( m.m!=0 && m.n!=0 )
            break;
    }while( 1 );

    create(m);
}

void create(Matrix& m){
    m.mat = new int*[m.m];

    for(int i=0; i<m.m; i++)
        m.mat[i] = new int[m.n];
}

void fillMatrix(Matrix m){
    srand(time(NULL));

    for(int i=0; i<m.m; i++)
        for(int j=0; j<m.n; j++)
            m.mat[i][j] = 10 + rand()%90;
}

void printMatrix(Matrix m){
    for(int i=0; i<m.m; i++){
        for(int j=0; j<m.n; j++)
            std::cout << std::setw(4) << m.mat[i][j];

        std::cout << std::endl;
    }
}

void destroy(Matrix& m){
    for(int i=0; i<m.m; i++)
        delete[] m.mat[i];

    delete[] m.mat;

    m.mat = NULL;
}

//01 Ingresar n�meros enteros a una matriz de tama�o N x M e intercambiar los elementos de la primera columna con la �ltima columna.
void intercambiarColumnas(Matrix m){
    Matrix mCopy;
    mCopy.m = m.m;
    mCopy.n = m.n;
    create(mCopy);

    for(int i=0; i<m.m; i++){
        for(int j=0; j<m.n; j++)
            if( j==0 )
                mCopy.mat[i][m.n-1] = m.mat[i][j];
            else if( j==(m.n-1) )
                mCopy.mat[i][0] = m.mat[i][j];
            else
                mCopy.mat[i][j] = m.mat[i][j];
    }

    std::cout << "Matriz original:" << std::endl;
    printMatrix(m);
    SALTO;
    std::cout << "Matriz con columnas intercambiadas:" << std::endl;
    printMatrix(mCopy);

    destroy(mCopy);
}

//02 Ingresar n�meros enteros a una matriz de tama�o N x M e intercambiar los elementos de la primera fila con la �ltima fila.
void intercambiarFilas(Matrix m){
    Matrix mCopy;
    mCopy.m = m.m;
    mCopy.n = m.n;
    create(mCopy);

    for(int i=0; i<m.m; i++){
        for(int j=0; j<m.n; j++)
            if( i==0 )
                mCopy.mat[m.m-1][j] = m.mat[i][j];
            else if( i==(m.m-1) )
                mCopy.mat[0][j] = m.mat[i][j];
            else
                mCopy.mat[i][j] = m.mat[i][j];
    }

    std::cout << "Matriz original:" << std::endl;
    printMatrix(m);
    SALTO;
    std::cout << "Matriz con filas intercambiadas:" << std::endl;
    printMatrix(mCopy);

    destroy(mCopy);
}

//03 Ingresar n�meros enteros a una matriz cuadrada de tama�o N e intercambiar los elementos de la primera columna con la �ltima fila.
void transponerFilaCol(Matrix m) {
    Matrix mCopy;
    mCopy.m = m.m;
    mCopy.n = m.n;
    create(mCopy);

    for(int i=0, j=m.n-1; i<m.m; i++, j--){
        mCopy.mat[m.m-1][j] = m.mat[i][0];
        mCopy.mat[i][0] = m.mat[m.m-1][j];
    }

    for(int i=0; i<m.m-1; i++)
        for(int j=1; j<m.n; j++)
            mCopy.mat[i][j] = m.mat[i][j];

    std::cout << "Matriz original:" << std::endl;
    printMatrix(m);
    SALTO;
    std::cout << "Matriz con columna-filas intercambiadas:" << std::endl;
    printMatrix(mCopy);

    destroy(mCopy);
}

//04 Ingresar n�meros enteros a una matriz cuadrada de tama�o N y calcular la suma de la diagonal principal y la suma de la diagonal secundaria.
void sumaDiagonales(Matrix m) {
    int *valoresPrincipal = new int[m.m];
    int *valoresSecundaria = new int[m.m];
    int diagonalPrincipal = 0;
    int diagonalSecundaria = 0;

    for(int i=0, j=0; i<m.m; i++, j++){
        diagonalPrincipal += m.mat[i][j];
        valoresPrincipal[i] = m.mat[i][j];
    }

    for(int i=0, j=m.n-1; i<m.m; i++, j--){
        diagonalSecundaria += m.mat[i][j];
        valoresSecundaria[i] = m.mat[i][j];
    }

    std::cout << "Matriz original:" << std::endl;
    printMatrix(m);
    SALTO;

    std::cout << "Suma diagonal principal: " << std::endl;
    for(int i=0; i<m.m; i++)
        std::cout << valoresPrincipal[i] << (i!=(m.m-1)?" + ":" = ");
    std::cout << diagonalPrincipal;

    SALTO;

    std::cout << "Suma diagonal secundaria: " << std::endl;
    for(int i=0; i<m.m; i++)
        std::cout << valoresSecundaria[i] << (i!=(m.m-1)?" + ":" = ");
    std::cout << diagonalSecundaria << std::endl;

    delete[] valoresPrincipal;
    delete[] valoresSecundaria;
}

//05 Ingresar n�meros enteros a una matriz cuadrada de tama�o N e intercambiar los elementos de la diagonal principal por los elementos de la �ltima fila de una matriz cuadrada.
void transponerDiagonalFila(Matrix m) {
    Matrix mCopy;
    mCopy.m = m.m;
    mCopy.n = m.n;
    create(mCopy);

    for(int i=0, j=0; i<m.m; i++, j++){
        mCopy.mat[m.m-1][j] = m.mat[i][j];
        mCopy.mat[i][j] = m.mat[m.m-1][j];
    }

    for(int i=0; i<m.m-1; i++)
        for(int j=0; j<m.n; j++)
            if( i!=j )
                mCopy.mat[i][j] = m.mat[i][j];

    std::cout << "Matriz original:" << std::endl;
    printMatrix(m);
    SALTO;
    std::cout << "Matriz con diagonal-fila intercambiadas:" << std::endl;
    printMatrix(mCopy);

    destroy(mCopy);
}

//06 Ingresar n�meros enteros a una matriz cuadrada de tama�o N y reemplazar por el n�mero 5 todos los elementos de la diagonal secundaria.
void reemplazarConCinco(Matrix m) {
    Matrix mCopy;
    mCopy.m = m.m;
    mCopy.n = m.n;
    create(mCopy);

    for(int i=0; i<m.m; i++)
        for(int j=0; j<m.n; j++)
            if( (i+j)==(m.m-1) )
                mCopy.mat[i][j] = 5;
            else
                mCopy.mat[i][j] = m.mat[i][j];

    std::cout << "Matriz original:" << std::endl;
    printMatrix(m);
    SALTO;
    std::cout << "Matriz con diagonal secundaria con 5's:" << std::endl;
    printMatrix(mCopy);

    destroy(mCopy);
}

//07 Ingresar n�meros enteros a una matriz de tama�o N x M, calcular el promedio de los n�meros pares de la matriz,
//luego hallar el mayor n�mero de toda la matriz y reemplazar los valores de la columna donde esta dicho n�mero mayor por el promedio antes calculado.
void promedioReemplazar(Matrix m) {
    Matrix mCopy;
    mCopy.m = m.m;
    mCopy.n = m.n;
    create(mCopy);
    int promedio = 0;
    int cantInts = 0;
    int mayor = m.mat[0][0];
    int colMayor = 0;

    for(int i=0; i<m.m; i++)
        for(int j=0; j<m.n; j++){
            if( m.mat[i][j]%2==0 ){
                promedio += m.mat[i][j];
                cantInts++;
            }

            if( mayor<m.mat[i][j] ){
                mayor = m.mat[i][j];
                colMayor = j;
            }
        }

    promedio /= cantInts;

    for(int i=0; i<m.m; i++)
        for(int j=0; j<m.n; j++)
            if( j==colMayor )
                mCopy.mat[i][j] = promedio;
            else
                mCopy.mat[i][j] = m.mat[i][j];

    std::cout << "Matriz original:" << std::endl;
    printMatrix(m);
    SALTO;
    std::cout << "Matriz con columna intercambiadas por promedio:" << std::endl;
    printMatrix(mCopy);

    SALTO;

    std::cout << "Cantidad de numeros pares: " << cantInts << std::endl;
    std::cout << "Promedio de numeros pares: " << promedio << std::endl;
    std::cout << "Numero mayor de la matriz: " << mayor << std::endl;
    std::cout << "Columna del numero mayor: " << colMayor << std::endl;

    destroy(mCopy);
}

//08 Ingresar n�meros enteros a una matriz de tama�o N x M, sumar todos los elementos que forman la letra O.
void sumaLetraO(Matrix m) {
    //int *numeros = new int[(2*(m.m+m.n)-4)];
    int suma = 0;

    for(int i=0; i<m.m; i++)
        for(int j=0; j<m.n; j++)
            if( i==0 || i==(m.m-1) || j==0 || j==(m.n-1) )
                suma += m.mat[i][j];

    std::cout << "Matriz original:" << std::endl;
    printMatrix(m);
    SALTO;

    std::cout << "Suma de numeros que forman la O:" << std::endl;

    for(int i=0; i<m.m; i++){
        for(int j=0; j<m.n; j++)
            if( i==0 || i==(m.m-1) || j==0 || j==(m.n-1) )
                std::cout << std::setw(4) << m.mat[i][j];
            else
                std::cout << "    ";

        std::cout << std::endl;
    }

    SALTO;
    std::cout << "La suma es de : " << suma;
    SALTO;

}


//09 Ingresar n�meros enteros a una matriz de tama�o N x M, calcular el promedio de todos los elementos que forman la letra L.
void promedioLetraL(Matrix m) {
    int promedio = 0;
    int cantNums = 0;

    for(int i=0; i<m.m; i++)
        for(int j=0; j<m.n; j++)
            if( j==0 || i==(m.m-1) ){
                promedio += m.mat[i][j];
                cantNums++;
            }

    promedio /= cantNums;

    std::cout << "Matriz original:" << std::endl;
    printMatrix(m);
    SALTO;

    std::cout << "Promedio de numeros que forman la L:" << std::endl;

    for(int i=0; i<m.m; i++){
        for(int j=0; j<m.n; j++)
            if( j==0 || i==(m.m-1) )
                std::cout << std::setw(4) << m.mat[i][j];
            else
                std::cout << "    ";

        std::cout << std::endl;
    }

    SALTO;
    std::cout << "La cantidad de elementos es de : " << cantNums << std::endl;
    std::cout << "El promedio es de: "  << promedio;
    SALTO;
}


//10 Ingresar n�meros enteros a una matriz de tama�o N x M, reemplazar por el n�mero 0 todos los elementos que forman la letra U.
void reemplazarLetraU(Matrix m) {
    Matrix mCopy;
    mCopy.m = m.m;
    mCopy.n = m.n;
    create(mCopy);

    for(int i=0; i<m.m; i++)
        for(int j=0; j<m.n; j++)
            if( j==0 || j==(m.n-1) || i==(m.m-1) )
                mCopy.mat[i][j] = 0;
            else
                mCopy.mat[i][j] = m.mat[i][j];

    std::cout << "Matriz original:" << std::endl;
    printMatrix(m);
    SALTO;
    std::cout << "Matriz con ceros letra U:" << std::endl;
    printMatrix(mCopy);

    destroy(mCopy);
}