/*

CONSIGNA:
---------

Mátriz dinámica promedio

A partir de una matriz dada de n filas por m columnas, la cual contiene números aleatorios menores a 20; 
se desea calcular otra matriz con las mismas dimensiones pero con la particularidad que, salvo su primer y ultimo elemento, 
el valor de cada uno de sus elementos es el resultado del promedio de la suma del elemento anterior, el actual y el siguiente.

Desarrolle un programa que sea capaz de generar la matriz original a partir de las dimensiones asignadas por el usuario, 
calcule la matriz resultado y la muestre por pantalla.

*/

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

#define MAX_VAL 20
#define MIN_VAL 0

int generar_matriz(int ** m, int filas, int cols);
int resolver_matriz(float ** pr, int filas, int cols);
void mostrar_matriz(void ** m, int filas, int cols);

int main(int argc, char *argv[])
{
    // Variables
    unsigned int filas, cols;
    
    // Acumuladores
    unsigned int i;
    
    // Matrices (original y promedio)
    int ** m;
    float ** pr;
    
    // Inicio de la app
    printf("Matriz dinamica aleatoria\n-------------------------\n");
    
    // Cantidad de filas
    printf("Ingrese cantidad de filas: ");
    scanf("%u", &filas);
    
    // Cantidad de columnas
    printf("Ingrese cantidad de columnas: ");
    scanf("%u", &cols);
    
    // Inicializacion de las matrices
    m = (int **)calloc(filas, sizeof(int *));
    pr = (float **)calloc(filas, sizeof(float *));
    
    // Verificar si fue correcta la inicialización
    if(m == NULL || pr == NULL)
    {
        printf("Error: No hay memoria disponible para la asignacion.\n");
        system("PAUSE");
        return -1;
    }
    
    // Asignación de filas y columnas
    for(i = 0; i < filas; i++)
    {
        m[i] = (int *)calloc(cols, sizeof(int));
        pr[i] = (float *)calloc(cols, sizeof(float));
        if(m[i] == NULL || pr[i] == NULL)
        {
            for(j = 0; j < i; j++)
            {
                free(m[j]);
                free(pr[j]);
            }
        }
    }
    
    // Generar matriz (original)
    generar_matriz(m, filas, cols);
    
    // Mostrar matriz (original)
    mostrar_matriz((int **)m, filas, cols);
    
    
    system("PAUSE");	
    return 0;
}

int generar_matriz(int ** m, int filas, int cols)
{
    unsigned int i, j;
    for(i = 0; i < filas; i++)
    {
        m[i] = (int *)calloc(cols, sizeof(int));
        if(m[i] == NULL)
        {
            free(m[i]);
        }
    }
    srand(time(0));
    for(i = 0; i < filas; i++)
        for(j = 0; j < filas; j++)
            m[i][j] = (rand()%MAX_VAL) + MIN_VAL;
}

void mostrar_matriz(void ** m, int filas, int cols)
{
    // Completar
}