En este post de programación en C, también conocido como ANSI C vamos a resolver un ejercicio propuesto que trabaja con matrices, calificaciones, alumnos, materias y promedios. Es un ejercicio que voy a resolver, el mismo dice así:

Escriba un programa que tenga implementadas las siguientes funciones:

1. Que reciba una matriz de nombre calificaciones y la llene de manera aleatoria con calificaciones de n alumnos y m materias. En la última columna de la matriz se calculará el promedio de cada alumno respectivamente.
2. Reciba la matriz anterior y una matriz con los nombres de los alumnos. La función imprimirá los datos de nombres y calificaciones de cada alumno, organizados como una tabla. Así mismo, calculará e imprimirá el menor y mayor promedio correspondiente al alumno o los alumnos respectivamente.

Veamos entonces el código

Explicación del algoritmo

Vamos a dividir los problemas. Primero veamos el de llenar la matriz de manera aleatoria, para ello vamos a hacer un ciclo for que va a recorrer toda la matriz y va a ir colocando un valor aleatorio en cada posición.

Después vamos a definir la segunda función que recibe la matriz para imprimirla, usando las alineaciones de printf para dibujar la tabla y los algoritmos para obtener el menor y mayor.

He colocado los enlaces anteriores para que profundices en caso de que no entiendas algo explicado aquí.

Definiendo matriz y constantes

Veamos la definición de constantes usando #define, veremos por ejemplo la cantidad de materias, alumnos, longitudes, etcétera.

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

#define CANTIDAD_ALUMNOS 3
#define CANTIDAD_MATERIAS 3
#define MAXIMA_CALIFICACION 100
#define MINIMA_CALIFICACION 0
#define MAXIMA_LONGITUD_CADENA 100

Recuerda que en este caso puedes cambiar los valores a tu gusto. Fíjate en que estamos definiendo también la calificación máxima y mínima para el caso de los números aleatorios. Por cierto, la función que vamos a usar es la siguiente:

int aleatorio_en_rango(int minimo, int maximo)
{
    return minimo + rand() / (RAND_MAX / (maximo - minimo + 1) + 1);
}

Llenar matriz de manera aleatoria

Ahora veamos la función que rellena la matriz con calificaciones aleatorias y coloca el promedio de las mismas en la última columna:

void llenarMatriz(float matriz[CANTIDAD_ALUMNOS][CANTIDAD_MATERIAS + 1])
{
    int y, x;
    for (y = 0; y < CANTIDAD_ALUMNOS; y++)
    {
        float suma = 0;
        for (x = 0; x < CANTIDAD_MATERIAS; x++)
        {
            int calificacion = aleatorio_en_rango(MINIMA_CALIFICACION, MAXIMA_CALIFICACION);
            suma += (float)calificacion;
            matriz[y][x] = calificacion;
        }
        // Agregar promedio
        float promedio = suma / CANTIDAD_MATERIAS;
        matriz[y][CANTIDAD_MATERIAS] = promedio;
    }
}

El promedio es calculado en la línea 14. Además, la calificación es asignada en la línea 11.

Antes de imprimir tabla: imprimir línea

Antes de pasar al segundo requerimiento, veamos una función que nos va a ayudar a imprimir una línea que va a separar la tabla. Te repito que si quieres aprender más sobre cómo alinear o rellenar al usar printf veas el enlace que dejé anteriormente.

void imprimirLinea()
{
    int x;
    printf("+----------");
    for (x = 0; x < CANTIDAD_MATERIAS + 1; x++)
    {
        printf("+--------");
    }
    printf("+\n");
}

Básicamente esa función del lenguaje C hará que se imprima una línea como la siguiente:

+----------+--------+--------+--------+--------+

Imprimir tabla de calificaciones con promedios

Ahora sí pasemos al segundo requisito. En este caso simplemente se trata de imprimir los valores y acomodarlos de una manera limpia. También debemos calcular el menor promedio y el mayor promedio, así como el nombre del alumno al que le pertenece cada uno:

void imprimir(float matriz[CANTIDAD_ALUMNOS][CANTIDAD_MATERIAS + 1], char alumnos[CANTIDAD_ALUMNOS][MAXIMA_LONGITUD_CADENA])
{
    int y, x;
    float promedioMayor = matriz[0][CANTIDAD_MATERIAS];
    float promedioMenor = matriz[0][CANTIDAD_MATERIAS];
    char alumnoPromedioMayor[MAXIMA_LONGITUD_CADENA];
    char alumnoPromedioMenor[MAXIMA_LONGITUD_CADENA];
    memcpy(alumnoPromedioMayor, alumnos[0], MAXIMA_LONGITUD_CADENA);
    memcpy(alumnoPromedioMenor, alumnos[0], MAXIMA_LONGITUD_CADENA);

    imprimirLinea();
    printf("|  Alumno  |");
    for (x = 0; x < CANTIDAD_MATERIAS; x++)
    {
        printf("Cal %d   |", x + 1);
    }
    printf("Promedio|\n");
    imprimirLinea();
    for (y = 0; y < CANTIDAD_ALUMNOS; y++)
    {
        printf("|%-10s|", alumnos[y]);
        float suma = 0;
        for (x = 0; x < CANTIDAD_MATERIAS; x++)
        {
            int calificacion = matriz[y][x];
            printf("%-7d |", calificacion);
        }
        float promedio = matriz[y][CANTIDAD_MATERIAS];
        if (promedio > promedioMayor)
        {
            promedioMayor = promedio;
            memcpy(alumnoPromedioMayor, alumnos[y], MAXIMA_LONGITUD_CADENA);
        }
        if (promedio < promedioMenor)
        {
            promedioMenor = promedio;
            memcpy(alumnoPromedioMenor, alumnos[y], MAXIMA_LONGITUD_CADENA);
        }
        printf("%0.2f   |\n", promedio);
        imprimirLinea();
    }
    printf("Promedio mayor: %s con %0.2f\n", alumnoPromedioMayor, promedioMayor);
    printf("Promedio menor: %s con %0.2f\n", alumnoPromedioMenor, promedioMenor);
}

Solo por si no lo sabes, usamos memcpy para asignar una cadena, ya que en C no podemos hacer algo como:

cadenaDeclaradaAnteriormente = "nueva cadena";

Poniendo todo junto

Recuerda que debes invocar a srand pasándole un valor distinto en la ejecución del programa para que los valores aleatorios sean distintos. Como sea, la función main junto con las demás funciones queda así:

/*
  ____          _____               _ _           _       
 |  _ \        |  __ \             (_) |         | |      
 | |_) |_   _  | |__) |_ _ _ __ _____| |__  _   _| |_ ___ 
 |  _ <| | | | |  ___/ _` | '__|_  / | '_ \| | | | __/ _ \
 | |_) | |_| | | |  | (_| | |   / /| | |_) | |_| | ||  __/
 |____/ \__, | |_|   \__,_|_|  /___|_|_.__/ \__, |\__\___|
         __/ |                               __/ |        
        |___/                               |___/         
    
____________________________________
/ Si necesitas ayuda, contáctame en \
\ https://parzibyte.me               /
 ------------------------------------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||
Creado por Parzibyte (https://parzibyte.me).
------------------------------------------------------------------------------------------------
Si el código es útil para ti, puedes agradecerme siguiéndome: https://parzibyte.me/blog/sigueme/
Y compartiendo mi blog con tus amigos
También tengo canal de YouTube: https://www.youtube.com/channel/UCroP4BTWjfM0CkGB6AFUoBg?sub_confirmation=1
------------------------------------------------------------------------------------------------
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define CANTIDAD_ALUMNOS 3
#define CANTIDAD_MATERIAS 3
#define MAXIMA_CALIFICACION 100
#define MINIMA_CALIFICACION 0
#define MAXIMA_LONGITUD_CADENA 100

int aleatorio_en_rango(int minimo, int maximo)
{
    return minimo + rand() / (RAND_MAX / (maximo - minimo + 1) + 1);
}

void llenarMatriz(float matriz[CANTIDAD_ALUMNOS][CANTIDAD_MATERIAS + 1])
{
    int y, x;
    for (y = 0; y < CANTIDAD_ALUMNOS; y++)
    {
        float suma = 0;
        for (x = 0; x < CANTIDAD_MATERIAS; x++)
        {
            int calificacion = aleatorio_en_rango(MINIMA_CALIFICACION, MAXIMA_CALIFICACION);
            suma += (float)calificacion;
            matriz[y][x] = calificacion;
        }
        // Agregar promedio
        float promedio = suma / CANTIDAD_MATERIAS;
        matriz[y][CANTIDAD_MATERIAS] = promedio;
    }
}

void imprimirLinea()
{
    int x;
    printf("+----------");
    for (x = 0; x < CANTIDAD_MATERIAS + 1; x++)
    {
        printf("+--------");
    }
    printf("+\n");
}

void imprimir(float matriz[CANTIDAD_ALUMNOS][CANTIDAD_MATERIAS + 1], char alumnos[CANTIDAD_ALUMNOS][MAXIMA_LONGITUD_CADENA])
{
    int y, x;
    float promedioMayor = matriz[0][CANTIDAD_MATERIAS];
    float promedioMenor = matriz[0][CANTIDAD_MATERIAS];
    char alumnoPromedioMayor[MAXIMA_LONGITUD_CADENA];
    char alumnoPromedioMenor[MAXIMA_LONGITUD_CADENA];
    memcpy(alumnoPromedioMayor, alumnos[0], MAXIMA_LONGITUD_CADENA);
    memcpy(alumnoPromedioMenor, alumnos[0], MAXIMA_LONGITUD_CADENA);

    imprimirLinea();
    printf("|  Alumno  |");
    for (x = 0; x < CANTIDAD_MATERIAS; x++)
    {
        printf("Cal %d   |", x + 1);
    }
    printf("Promedio|\n");
    imprimirLinea();
    for (y = 0; y < CANTIDAD_ALUMNOS; y++)
    {
        printf("|%-10s|", alumnos[y]);
        float suma = 0;
        for (x = 0; x < CANTIDAD_MATERIAS; x++)
        {
            int calificacion = matriz[y][x];
            printf("%-7d |", calificacion);
        }
        float promedio = matriz[y][CANTIDAD_MATERIAS];
        if (promedio > promedioMayor)
        {
            promedioMayor = promedio;
            memcpy(alumnoPromedioMayor, alumnos[y], MAXIMA_LONGITUD_CADENA);
        }
        if (promedio < promedioMenor)
        {
            promedioMenor = promedio;
            memcpy(alumnoPromedioMenor, alumnos[y], MAXIMA_LONGITUD_CADENA);
        }
        printf("%0.2f   |\n", promedio);
        imprimirLinea();
    }
    printf("Promedio mayor: %s con %0.2f\n", alumnoPromedioMayor, promedioMayor);
    printf("Promedio menor: %s con %0.2f\n", alumnoPromedioMenor, promedioMenor);
}

int main()
{
    srand(getpid());
    float matriz[CANTIDAD_ALUMNOS][CANTIDAD_MATERIAS + 1];
    char alumnos[CANTIDAD_ALUMNOS][MAXIMA_LONGITUD_CADENA] = {
        "Luis",
        "Pedro",
        "Maria",
    };
    llenarMatriz(matriz);
    imprimir(matriz, alumnos);
}

Yo lo he ejecutado y funciona perfectamente:

Por otro lado, puedes leer más sobre C en mi blog.