Implementación de Algoritmos Fundamentales en C: Media y Cuadrados Mágicos

Introducción a la Programación en C

Este documento presenta dos ejemplos prácticos de programación en C, abordando conceptos fundamentales como la entrada/salida de datos, bucles, cálculos matemáticos y manipulación de matrices. Se explorará el cálculo de la media aritmética y una implementación del algoritmo para generar cuadrados mágicos.

1. Cálculo de la Media Aritmética y Raíz Cuadrada del Promedio

Este primer programa en C permite al usuario introducir una serie de números para calcular su media aritmética. Adicionalmente, se calcula la raíz cuadrada de dicha media, un valor que, aunque no es la desviación estándar, se presenta como un ejemplo de operación matemática.

Código Fuente:

#include <stdio.h>
#include <conio.h>
#include <math.h>

int main() {
    float num, snum = 0, media, raiz_media;
    int cont = 1, can;

    printf("\t\t\nIntroduce de cuántos números quieres hacer la media\n");
    scanf("%d", &can);

    while (cont <= can) {
        printf("\t\t\nIntroduce valor número %d\n\n\t", cont);
        scanf("%f", &num);
        cont++;
        snum = snum + num;
    }

    media = snum / can;
    raiz_media = sqrt(media); // Nota: Esta es la raíz cuadrada de la media, no la desviación estándar.

    printf("\n\t La media de los números introducidos es %f", media);
    printf("\n\t La raíz cuadrada de la media de los números introducidos es %f", raiz_media);
    getch();
    return 0; // Añadido para buena práctica
}

Explicación del Código:

• Se utilizan las librerías stdio.h para entrada/salida, conio.h para getch() y math.h para sqrt().
• El programa solicita al usuario la cantidad de números a promediar.
• Mediante un bucle while, se piden los números uno por uno y se acumula su suma.
• La media aritmética se calcula dividiendo la suma total entre la cantidad de números.
• La variable raiz_media almacena la raíz cuadrada de la media. Es importante destacar que este valor no corresponde a la desviación estándar, la cual requiere un cálculo diferente que involucra las diferencias de cada número respecto a la media.

2. Generación de Cuadrados Mágicos (Algoritmo de Siam)

Este segundo programa implementa un algoritmo para generar un cuadrado mágico de orden impar. Un cuadrado mágico es una matriz cuadrada de números enteros donde la suma de los números en cada fila, cada columna y ambas diagonales principales es la misma.

Conceptos Clave:

• Orden Impar: El algoritmo implementado es específico para matrices cuadradas con un número impar de filas y columnas (ej. 3x3, 5x5, 7x7).
• Algoritmo de Siam: Este método comienza colocando el número 1 en la celda central de la primera fila. Los números subsiguientes se colocan en la diagonal superior derecha. Se aplican reglas específicas para manejar los límites de la matriz y las celdas ya ocupadas.

Código Fuente:

#include <stdio.h>
#include <stdlib.h> // Para system("PAUSE")

// Constantes a utilizar en el programa
#define CUANTOS 5

// Función principal del programa
int main(int argc, char *argv[]) {
    // Creación de la matriz que contendrá los números
    // esta matriz se crea utilizando la constante creada
    // anteriormente. Se ha de tener en cuenta que para que
    // funcione correctamente el programa, la matriz ha de ser
    // cuadrada y de orden impar.
    int Matriz[CUANTOS][CUANTOS];

    // Variable a utilizar como contador de números
    int contador = 0;

    // Variables a utilizar para determinar la posición x e y en la matriz,
    // almacenar las posiciones y los límites de la matriz.
    int x = 0;
    int y = 0;
    int vx = 0;
    int vy = 0;

    // Número de números que hay que contar y límites de la matriz
    int limite = CUANTOS * CUANTOS;
    int limitex = CUANTOS - 1;
    int limitey = CUANTOS - 1;

    // Inicializar los valores de la matriz a 0
    for (x = 0; x < CUANTOS; x++) {
        for (y = 0; y < CUANTOS; y++) {
            Matriz[x][y] = 0;
        }
    }

    // Establecer la posición x e y inicial de la matriz donde almacenar
    // el primer número, siendo en la primera fila, posición central.
    x = CUANTOS / 2;
    y = 0;

    // El primer número se sitúa en la casilla central de la fila
    // superior de la matriz. A continuación, el siguiente número se
    // sitúa en la diagonal arriba derecha, es decir, una posición
    // de fila más alta y una posición de columna a la derecha. En
    // caso de ya estar ocupada la casilla, se sitúa el número correspondiente
    // debajo de la casilla de donde se partía inicialmente. Si al
    // desplazarse por la matriz se superan los límites por algún sitio,
    // se entra a la misma por el lado contrario, es decir, si nos pasamos
    // de posición por la parte derecha de la matriz, se empieza por la parte
    // izquierda de la misma, y así en todos los sentidos.

    // Bucle que se ejecuta el número de casillas que contiene la matriz
    for (contador = 1; contador <= limite; contador++) {
        // Asignar la posición del número en la matriz
        Matriz[y][x] = contador;

        // Guardar la posición actual
        vx = x;
        vy = y;

        // Aumentar la posición de x (columna) y disminuir la de y (fila)
        // para avanzar en diagonal (arriba-derecha).
        x++;
        if (x > limitex) x = 0; // Si sobrepasa el límite derecho, situarla en el límite izquierdo.

        y--;
        if (y < 0) y = limitey; // Si sobrepasa el límite superior, situarla en el límite inferior.

        // Se comprueba si la posición ya está ocupada por un número.
        // Si es así, se vuelve a la posición original y se resitúa el
        // número justo en la casilla inferior.
        if (Matriz[y][x] > 0) {
            // La casilla está ocupada y se asigna el número en la
            // casilla situada justo debajo de la casilla de donde procedía.
            x = vx;
            y = vy + 1;
        }
    }

    // Visualizar la matriz
    printf("\nCUADRADO MÁGICO - WWW.APRENDOENCASA.COM\n");
    for (x = 0; x < CUANTOS; x++) {
        for (y = 0; y < CUANTOS; y++) {
            printf("|%3d|", Matriz[x][y]);
        }
        printf("\n");
    }

    printf("\nGRACIAS POR SU VISITA - WWW.APRENDOENCASA.ES\n\n");
    system("PAUSE");
    return 0;
}

Funcionamiento del Algoritmo:

1. Inicio: El número 1 se coloca en la celda central de la primera fila (x = CUANTOS / 2, y = 0).
2. Movimiento Diagonal: Para cada número subsiguiente, se intenta mover una posición a la derecha y una posición hacia arriba (x++, y--).
3. Reglas de Borde:
   • Si el movimiento excede el límite derecho (x > limitex), se "envuelve" al lado izquierdo (x = 0).
   • Si el movimiento excede el límite superior (y < 0), se "envuelve" al lado inferior (y = limitey).
4. Celda Ocupada: Si la celda calculada ya contiene un número (Matriz[y][x] > 0), significa que la celda está ocupada. En este caso, el número actual se coloca directamente debajo de la posición anterior (x = vx, y = vy + 1).
5. Visualización: Una vez llenada la matriz, se imprime en formato tabular para mostrar el cuadrado mágico resultante.

Este algoritmo garantiza que, para cualquier orden impar, la suma de filas, columnas y diagonales principales sea la misma, demostrando una fascinante propiedad matemática.