Implementación y Cálculo de Diagonales de Matrices Cuadradas en C

Optimización de Código C para el Manejo de Matrices Cuadradas

A continuación, se presenta la refactorización y corrección del código fuente en C, diseñado para generar una matriz cuadrada, llenarla con valores aleatorios y calcular los promedios de sus diagonales principal y secundaria. Se han añadido las librerías necesarias y se ha mejorado la estructura y legibilidad del código, manteniendo intacta la lógica original.

Código C Corregido y Estructurado

Se han incluido las librerías <stdlib.h> y <time.h>, esenciales para la generación de números pseudoaleatorios, y se ha estandarizado la indentación.

#include <stdio.h>
#include <stdlib.h> // Necesario para rand() y srand()
#include <time.h>   // Necesario para time()
#include <windows.h> // Para system("pause")

// Declaración de funciones
void guarda();
void imprime();
void principal();
void secundaria();

// Variables globales (Nota: Se recomienda evitar variables globales en proyectos grandes)
int F, C, vec[10][10], i, j;
float sp, ss, pp, ps; // Suma principal, Suma secundaria, Promedio principal, Promedio secundario

int main()
{
    guarda();
    principal();
    secundaria();
    imprime();
    printf("\n");
    system("pause");
    return 0;
}

void guarda()
{
    // Inicialización de la semilla del generador de números aleatorios
    int hora = time(NULL);
    
    do
    {
        printf("Numero de filas: ");
        scanf("%d", &F);
        printf("Numero de columnas: ");
        scanf("%d", &C);
    } while (F != C); // Asegura que la matriz sea cuadrada
    
    srand(hora);
    
    // Llenado de la matriz con números aleatorios entre 0 y 9
    for (i = 0; i < F; i++)
    {
        for (j = 0; j < C; j++)
        {
            vec[i][j] = rand() % 10;
        }
    }
    return;
}

void principal()
{
    sp = 0.0;
    // Cálculo de la suma de la diagonal principal (i == j)
    for (i = 0; i < F; i++)
    {
        for (j = 0; j < C; j++)
        {
            if (i == j)
            {
                sp = sp + vec[i][j];
            }
        }
    }
    // Cálculo del promedio de la diagonal principal
    pp = sp / F;
    return;
}

void secundaria()
{
    ss = 0.0;
    // Cálculo de la suma de la diagonal secundaria (i + j == F - 1)
    for (i = 0; i < F; i++)
    {
        for (j = 0; j < C; j++)
        {
            if (i + j == F - 1)
            {
                ss = ss + vec[i][j];
            }
        }
    }
    // Cálculo del promedio de la diagonal secundaria
    ps = ss / F;
    return;
}

void imprime()
{
    // Impresión de la matriz
    for (i = 0; i < F; i++)
    {
        for (j = 0; j < C; j++)
        {
            printf("%d\t", vec[i][j]);
        }
        printf("\n");
    }
    
    // Impresión de resultados
    printf("Promedio de la diagonal principal: %f", pp);
    printf("\n");
    printf("Promedio de la diagonal secundaria: %f", ps);
    return;
}

Detalles de la Implementación y Funcionalidad

El programa está modularizado en funciones claras, cada una con una responsabilidad específica, facilitando la comprensión del flujo de datos y cálculos.

Función guarda(): Inicialización y Validación

• Validación de Entrada: El bucle do-while asegura que el número de filas (F) y columnas (C) sea idéntico, condición indispensable para el cálculo de ambas diagonales.
• Generación Aleatoria: Se utiliza srand(time(NULL)) para inicializar la semilla, garantizando la aleatoriedad de los elementos de la matriz (valores entre 0 y 9).

Función principal(): Cálculo de la Diagonal Principal

Esta función suma los elementos donde el índice de fila i es igual al índice de columna j (if(i == j)). El promedio (pp) se obtiene dividiendo la suma total (sp) entre el número de filas (F).

Función secundaria(): Cálculo de la Diagonal Secundaria

Identifica los elementos de la diagonal secundaria mediante la condición if(i + j == F - 1). El promedio (ps) se calcula dividiendo la suma (ss) entre F.

Función imprime(): Visualización de Resultados

Muestra la matriz generada y presenta los resultados finales de los promedios calculados para ambas diagonales, utilizando el formato %f para los valores flotantes.