Programación estructurada

Diseño modular

Diseño modular

El diseño modular (o programación modular) está basado en la estrategia de dividir un problema complejo en problemas más pequeños, hasta que éstos sean fáciles de tratar y resolver por separado

 

De este modo, la solución al problema completo está dada por la solución de todos estos subproblemas

Diseño modular

O, de manera más concreta, se trata de dividir un programa en módulos que realicen tareas concretas y simples

 

Dependiendo del lenguaje al que nos refiramos, estos módulos son rutinas, procedimientos, clases, métodos o funciones

Diseño modular

El otro beneficio del diseño modular es que permite la reutilización del código (en el mismo programa o, preferentemente, en otros programas distintos)

 

DRY: Don't Repeat Yourself

Funciones

En la medida de lo posible, las funciones deben ser diseñadas de acuerdo a:

  • Cumplir bien una sola tarea
  • Tener alta cohesión; las instrucciones de la función deben contribuir a la solución general del problema
  • Tener bajo acoplamiento; la dependencia entre funciones debe ser mínima y, por tanto, no deberían existir datos compartidos entre funciones

Funciones

Podemos escribir las funciones que necesitemos de la siguiente forma:

int cuadrado(int n)
{
	int valor = n*n;
    return valor;
}

Funciones

Podemos escribir las funciones que necesitemos de la siguiente forma:

  • Definimos el prototipo de la función, que incluye el tipo de valor que va a regresar, el nombre de la función y los parámetros que recibe junto con el tipo de cada uno
int cuadrado(int n)
{
	int valor = n*n;
    return valor;
}

Funciones

Podemos escribir las funciones que necesitemos de la siguiente forma:

  • Definimos el prototipo de la función, que incluye el tipo de valor que va a regresar, el nombre de la función y los parámetros que recibe junto con el tipo de cada uno
  • El bloque de código de la función
int cuadrado(int n)
{
	int valor = n*n;
    return valor;
}

Funciones

Podemos escribir las funciones que necesitemos de la siguiente forma:

  • Definimos el prototipo de la función, que incluye el tipo de valor que va a regresar, el nombre de la función y los parámetros que recibe junto con el tipo de cada uno
  • El bloque de código de la función
  • Las instrucciones a ejecutar cuando se llame la función
int cuadrado(int n)
{
	int valor = n*n;
    return valor;
}

Funciones

Podemos escribir las funciones que necesitemos de la siguiente forma:

  • Definimos el prototipo de la función, que incluye el tipo de valor que va a regresar, el nombre de la función y los parámetros que recibe junto con el tipo de cada uno
  • El bloque de código de la función
  • Las instrucciones a ejecutar cuando se llame la función
  • El valor que regresa la función
int cuadrado(int n)
{
	int valor = n*n;
    return valor;
}

Un archivo de cabecera es un archvo con extensión .h que contiene la definición de macros, funciones y tipos de datos que pueden ser usadas por archivos de programas regulares (con extensión .c o .cpp)

 

Un archivo de cabecera se manda llamar de la siguiente forma:

Archivos de cabecera

#include "archivo.h"

Cualquier definición en este tipo de archivos puede usarse libremente en cualquier otro archivo una vez que haya sido incluído por este último

Un archivo de cabecera, por ejemplo, puede verse así:

Archivos de cabecera

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

int cuadrado(int n)
{
	int valor = n*n;
    return valor;
}

Como ya se mencionó, los arreglos se pasan por referencia, no por valor

Arreglos

#define MAXIMO 10

int imprimeArreglo(int arreglo[MAXIMO], int n) {
    int i = 0;
    printf("El arreglo es:\n");
    for (i = 0; i < n; i++) {
    	printf("%d\t", arreglo[i]);
        printf("\n");
    }
    return 0;
}

La definición de la función

imprimeArreglo(arreglo, n);

Cómo se llama la función

Además, es necesario mandar el valor del tamaño del arreglo junto con el arreglo cuando lo usamos como parámetro

Cuadrado mágico

#include <stdio.h>
#define MAXIMO 10

int main()
{
	int n=0;
	int suma=0;
	int comparacion=0;
	int numero=0;
	int matriz[MAXIMO][MAXIMO]= {};
	int i=0;
	int j=0;

	printf("Ingrese un número entre 3 y %d: ", MAXIMO);
	scanf("%d", &n);
	if (n<3)
	{
		printf("El número ingresado es menor a 3");
		return 1;
	}
	if (n>MAXIMO) {
		printf("El número ingresado es mayor que %d", MAXIMO);
		return 2;
	}
	
	suma = ((n*n)*((n*n)+1))/(2*n);
	printf("La suma de cada fila, columna y diagonal debe ser %d para que la matriz sea un cuadrado mágico\n", suma);
	
	for(i=0; i<n; i++)
	{
		for(j=0; j<n; j++)
		{
			printf("Ingrese el número correspondiente a la fila %d y columna %d: ", i, j);
			scanf("%d", &numero);
			matriz[i][j] = numero;
			if ((numero<1)||(numero>(n*n)))
			{
			    printf("Los números de un cuadrado mágico deben ser entre el 1 y el %d, por lo que la matriz no es un cuadrado mágico",(n*n));
			    return 3;
			}
		}
	}

	printf("La matriz es:\n");
	for(i=0; i<n; i++)
	{
		for(j=0; j<n; j++)
		{
			printf("%d\t", matriz[i][j]);
		}
		printf("\n");
	}

	for(i=0; i<n; i++)
	{
		comparacion=0;
		for(j=0; j<n; j++)
		{
			comparacion+=matriz[i][j];
		}
		if (comparacion!=suma) {
			printf("La suma de la fila %d es %d, por lo que la matriz no es un cuadrado mágico", i, comparacion);
			return 4;
		}
	}

	for(j=0; j<n; j++)
	{
		comparacion=0;
		for(i=0; i<n; i++)
		{
			comparacion+=matriz[i][j];
		}
		if (comparacion!=suma) {
			printf("La suma de la columna %d es %d, por lo que la matriz no es un cuadrado mágico", j, comparacion);
			return 5;
		}
	}

	comparacion=0;
	for(i=0, j=0; i<n; i++, j++)
	{
		comparacion+=matriz[i][j];
	}
	if (comparacion!=suma) {
		printf("La suma de la primera diagonal es %d, por lo que la matriz no es un cuadrado mágico", comparacion);
		return 6;
	}

	comparacion=0;
	for(i=0, j=(n-1); i<n; i++, j--)
	{
		comparacion+=matriz[i][j];
	}
	if (comparacion!=suma) {
		printf("La suma de la segunda diagonal es %d, por lo que la matriz no es un cuadrado mágico", comparacion);
		return 7;
	}

	printf("La matriz es un cuadrado mágico");
	return 0;
}

Ejemplo 1

Cuadrado mágico

#include <stdio.h>
#include "matriz.h"

int main()
{
	int n=0;
	int suma=0;
	int numero=0;
	int matriz[MAXIMO][MAXIMO]= {};
	int i=0;
	int j=0;
	int retorno=0;

	printf("Ingrese un número entre 3 y %d: ", MAXIMO);
	scanf("%d", &n);
	retorno=revisaRango(n,3,MAXIMO);
	if (retorno!=0)
	{
		return retorno;
	}

	suma = obtenSuma(n);
	printf("La suma de cada fila, columna y diagonal debe ser %d para que la matriz sea un cuadrado mágico\n", suma);

	for(i=0; i<n; i++)
	{
		for(j=0; j<n; j++)
		{
			printf("Ingrese el número correspondiente a la fila %d y columna %d: ", i, j);
			scanf("%d", &numero);
			retorno=revisaValorCorrecto(numero, n);
			if (retorno==0)
			{
				matriz[i][j] = numero;
			}
			else
			{
				return retorno;
			}
		}
	}

	imprimeMatriz(matriz, n);

	retorno = comparaFilas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaColumnas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaDiagonales(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	printf("La matriz es un cuadrado mágico");
	return retorno;
}

Ejemplo 2

#define MAXIMO 10

int revisaRango(int n, int min, int max) {
    int retorno = 0;
    if (n < 3) {
        printf("El número ingresado es menor a 3");
        retorno = 1;
    }
    if (n > MAXIMO) {
        printf("El número ingresado es mayor que %d", MAXIMO);
        retorno = 2;
    }
    return retorno;
}

int obtenSuma(int n) {
    return ((n * n) * ((n * n) + 1)) / (2 * n);
}

int revisaValorCorrecto(int numero, int n) {
    int retorno = 0;
    if ((numero < 1) || (numero > (n * n))) {
        printf("Los números de un cuadrado mágico deben ser entre el 1 y el %d, por lo que la matriz no es un cuadrado mágico", (n * n));
        retorno = 3;
    }
    return retorno;
}

int imprimeMatriz(int matriz[MAXIMO][MAXIMO], int n) {
    int i = 0;
    int j = 0;
    printf("La matriz es:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d\t", matriz[i][j]);
        }
        printf("\n");
    }
    return 0;
}

int comparaFilas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (i = 0; i < n; i++) {
        comparacion = 0;
        for (j = 0; j < n; j++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la fila %d es %d, por lo que la matriz no es un cuadrado mágico\n", i, comparacion);
            retorno = 4;
            return retorno;
        }
    }
    return retorno;
}

int comparaColumnas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (j = 0; j < n; j++) {
        comparacion = 0;
        for (i = 0; i < n; i++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la columna %d es %d, por lo que la matriz no es un cuadrado mágico\n", j, comparacion);
            retorno = 5;
            return retorno;
        }
    }
    return retorno;
}

int comparaDiagonales(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    comparacion = 0;
    for (i = 0, j = 0; i < n; i++, j++) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la primera diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 6;
        return retorno;
    }

    comparacion = 0;
    for (i = 0, j = (n - 1); i < n; i++, j--) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la segunda diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 7;
        return retorno;
    }
    return retorno;
}

main.c

matriz.h

Cuadrado mágico

#include <stdio.h>
#include "matriz.h"

int main()
{
	int n=0;
	int suma=0;
	int numero=0;
	int matriz[MAXIMO][MAXIMO]= {};
	int i=0;
	int j=0;
	int retorno=0;

	printf("Ingrese un número entre 3 y %d: ", MAXIMO);
	scanf("%d", &n);
	retorno=revisaRango(n,3,MAXIMO);
	if (retorno!=0)
	{
		return retorno;
	}

	suma = obtenSuma(n);
	printf("La suma de cada fila, columna y diagonal debe ser %d para que la matriz sea un cuadrado mágico\n", suma);

	for(i=0; i<n; i++)
	{
		for(j=0; j<n; j++)
		{
			printf("Ingrese el número correspondiente a la fila %d y columna %d: ", i, j);
			scanf("%d", &numero);
			retorno=revisaValorCorrecto(numero, n);
			if (retorno==0)
			{
				matriz[i][j] = numero;
			}
			else
			{
				return retorno;
			}
		}
	}

	imprimeMatriz(matriz, n);

	retorno = comparaFilas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaColumnas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaDiagonales(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	printf("La matriz es un cuadrado mágico");
	return retorno;
}

Ejemplo 2

#define MAXIMO 10

int revisaRango(int n, int min, int max) {
    int retorno = 0;
    if (n < 3) {
        printf("El número ingresado es menor a 3");
        retorno = 1;
    }
    if (n > MAXIMO) {
        printf("El número ingresado es mayor que %d", MAXIMO);
        retorno = 2;
    }
    return retorno;
}

int obtenSuma(int n) {
    return ((n * n) * ((n * n) + 1)) / (2 * n);
}

int revisaValorCorrecto(int numero, int n) {
    int retorno = 0;
    if ((numero < 1) || (numero > (n * n))) {
        printf("Los números de un cuadrado mágico deben ser entre el 1 y el %d, por lo que la matriz no es un cuadrado mágico", (n * n));
        retorno = 3;
    }
    return retorno;
}

int imprimeMatriz(int matriz[MAXIMO][MAXIMO], int n) {
    int i = 0;
    int j = 0;
    printf("La matriz es:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d\t", matriz[i][j]);
        }
        printf("\n");
    }
    return 0;
}

int comparaFilas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (i = 0; i < n; i++) {
        comparacion = 0;
        for (j = 0; j < n; j++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la fila %d es %d, por lo que la matriz no es un cuadrado mágico\n", i, comparacion);
            retorno = 4;
            return retorno;
        }
    }
    return retorno;
}

int comparaColumnas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (j = 0; j < n; j++) {
        comparacion = 0;
        for (i = 0; i < n; i++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la columna %d es %d, por lo que la matriz no es un cuadrado mágico\n", j, comparacion);
            retorno = 5;
            return retorno;
        }
    }
    return retorno;
}

int comparaDiagonales(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    comparacion = 0;
    for (i = 0, j = 0; i < n; i++, j++) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la primera diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 6;
        return retorno;
    }

    comparacion = 0;
    for (i = 0, j = (n - 1); i < n; i++, j--) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la segunda diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 7;
        return retorno;
    }
    return retorno;
}

main.c

matriz.h

Cuadrado mágico

#include <stdio.h>
#include "matriz.h"

int main()
{
	int n=0;
	int suma=0;
	int numero=0;
	int matriz[MAXIMO][MAXIMO]= {};
	int i=0;
	int j=0;
	int retorno=0;

	printf("Ingrese un número entre 3 y %d: ", MAXIMO);
	scanf("%d", &n);
	retorno=revisaRango(n,3,MAXIMO);
	if (retorno!=0)
	{
		return retorno;
	}

	suma = obtenSuma(n);
	printf("La suma de cada fila, columna y diagonal debe ser %d para que la matriz sea un cuadrado mágico\n", suma);

	for(i=0; i<n; i++)
	{
		for(j=0; j<n; j++)
		{
			printf("Ingrese el número correspondiente a la fila %d y columna %d: ", i, j);
			scanf("%d", &numero);
			retorno=revisaValorCorrecto(numero, n);
			if (retorno==0)
			{
				matriz[i][j] = numero;
			}
			else
			{
				return retorno;
			}
		}
	}

	imprimeMatriz(matriz, n);

	retorno = comparaFilas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaColumnas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaDiagonales(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	printf("La matriz es un cuadrado mágico");
	return retorno;
}

Ejemplo 2

#define MAXIMO 10

int revisaRango(int n, int min, int max) {
    int retorno = 0;
    if (n < 3) {
        printf("El número ingresado es menor a 3");
        retorno = 1;
    }
    if (n > MAXIMO) {
        printf("El número ingresado es mayor que %d", MAXIMO);
        retorno = 2;
    }
    return retorno;
}

int obtenSuma(int n) {
    return ((n * n) * ((n * n) + 1)) / (2 * n);
}

int revisaValorCorrecto(int numero, int n) {
    int retorno = 0;
    if ((numero < 1) || (numero > (n * n))) {
        printf("Los números de un cuadrado mágico deben ser entre el 1 y el %d, por lo que la matriz no es un cuadrado mágico", (n * n));
        retorno = 3;
    }
    return retorno;
}

int imprimeMatriz(int matriz[MAXIMO][MAXIMO], int n) {
    int i = 0;
    int j = 0;
    printf("La matriz es:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d\t", matriz[i][j]);
        }
        printf("\n");
    }
    return 0;
}

int comparaFilas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (i = 0; i < n; i++) {
        comparacion = 0;
        for (j = 0; j < n; j++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la fila %d es %d, por lo que la matriz no es un cuadrado mágico\n", i, comparacion);
            retorno = 4;
            return retorno;
        }
    }
    return retorno;
}

int comparaColumnas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (j = 0; j < n; j++) {
        comparacion = 0;
        for (i = 0; i < n; i++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la columna %d es %d, por lo que la matriz no es un cuadrado mágico\n", j, comparacion);
            retorno = 5;
            return retorno;
        }
    }
    return retorno;
}

int comparaDiagonales(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    comparacion = 0;
    for (i = 0, j = 0; i < n; i++, j++) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la primera diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 6;
        return retorno;
    }

    comparacion = 0;
    for (i = 0, j = (n - 1); i < n; i++, j--) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la segunda diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 7;
        return retorno;
    }
    return retorno;
}

main.c

matriz.h

Cuadrado mágico

#include <stdio.h>
#include "matriz.h"

int main()
{
	int n=0;
	int suma=0;
	int numero=0;
	int matriz[MAXIMO][MAXIMO]= {};
	int i=0;
	int j=0;
	int retorno=0;

	printf("Ingrese un número entre 3 y %d: ", MAXIMO);
	scanf("%d", &n);
	retorno=revisaRango(n,3,MAXIMO);
	if (retorno!=0)
	{
		return retorno;
	}

	suma = obtenSuma(n);
	printf("La suma de cada fila, columna y diagonal debe ser %d para que la matriz sea un cuadrado mágico\n", suma);

	for(i=0; i<n; i++)
	{
		for(j=0; j<n; j++)
		{
			printf("Ingrese el número correspondiente a la fila %d y columna %d: ", i, j);
			scanf("%d", &numero);
			retorno=revisaValorCorrecto(numero, n);
			if (retorno==0)
			{
				matriz[i][j] = numero;
			}
			else
			{
				return retorno;
			}
		}
	}

	imprimeMatriz(matriz, n);

	retorno = comparaFilas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaColumnas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaDiagonales(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	printf("La matriz es un cuadrado mágico");
	return retorno;
}

Ejemplo 2

#define MAXIMO 10

int revisaRango(int n, int min, int max) {
    int retorno = 0;
    if (n < 3) {
        printf("El número ingresado es menor a 3");
        retorno = 1;
    }
    if (n > MAXIMO) {
        printf("El número ingresado es mayor que %d", MAXIMO);
        retorno = 2;
    }
    return retorno;
}

int obtenSuma(int n) {
    return ((n * n) * ((n * n) + 1)) / (2 * n);
}

int revisaValorCorrecto(int numero, int n) {
    int retorno = 0;
    if ((numero < 1) || (numero > (n * n))) {
        printf("Los números de un cuadrado mágico deben ser entre el 1 y el %d, por lo que la matriz no es un cuadrado mágico", (n * n));
        retorno = 3;
    }
    return retorno;
}

int imprimeMatriz(int matriz[MAXIMO][MAXIMO], int n) {
    int i = 0;
    int j = 0;
    printf("La matriz es:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d\t", matriz[i][j]);
        }
        printf("\n");
    }
    return 0;
}

int comparaFilas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (i = 0; i < n; i++) {
        comparacion = 0;
        for (j = 0; j < n; j++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la fila %d es %d, por lo que la matriz no es un cuadrado mágico\n", i, comparacion);
            retorno = 4;
            return retorno;
        }
    }
    return retorno;
}

int comparaColumnas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (j = 0; j < n; j++) {
        comparacion = 0;
        for (i = 0; i < n; i++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la columna %d es %d, por lo que la matriz no es un cuadrado mágico\n", j, comparacion);
            retorno = 5;
            return retorno;
        }
    }
    return retorno;
}

int comparaDiagonales(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    comparacion = 0;
    for (i = 0, j = 0; i < n; i++, j++) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la primera diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 6;
        return retorno;
    }

    comparacion = 0;
    for (i = 0, j = (n - 1); i < n; i++, j--) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la segunda diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 7;
        return retorno;
    }
    return retorno;
}

main.c

matriz.h

Cuadrado mágico

#include <stdio.h>
#include "matriz.h"

int main()
{
	int n=0;
	int suma=0;
	int numero=0;
	int matriz[MAXIMO][MAXIMO]= {};
	int i=0;
	int j=0;
	int retorno=0;

	printf("Ingrese un número entre 3 y %d: ", MAXIMO);
	scanf("%d", &n);
	retorno=revisaRango(n,3,MAXIMO);
	if (retorno!=0)
	{
		return retorno;
	}

	suma = obtenSuma(n);
	printf("La suma de cada fila, columna y diagonal debe ser %d para que la matriz sea un cuadrado mágico\n", suma);

	for(i=0; i<n; i++)
	{
		for(j=0; j<n; j++)
		{
			printf("Ingrese el número correspondiente a la fila %d y columna %d: ", i, j);
			scanf("%d", &numero);
			retorno=revisaValorCorrecto(numero, n);
			if (retorno==0)
			{
				matriz[i][j] = numero;
			}
			else
			{
				return retorno;
			}
		}
	}

	imprimeMatriz(matriz, n);

	retorno = comparaFilas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaColumnas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaDiagonales(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	printf("La matriz es un cuadrado mágico");
	return retorno;
}

Ejemplo 2

#define MAXIMO 10

int revisaRango(int n, int min, int max) {
    int retorno = 0;
    if (n < 3) {
        printf("El número ingresado es menor a 3");
        retorno = 1;
    }
    if (n > MAXIMO) {
        printf("El número ingresado es mayor que %d", MAXIMO);
        retorno = 2;
    }
    return retorno;
}

int obtenSuma(int n) {
    return ((n * n) * ((n * n) + 1)) / (2 * n);
}

int revisaValorCorrecto(int numero, int n) {
    int retorno = 0;
    if ((numero < 1) || (numero > (n * n))) {
        printf("Los números de un cuadrado mágico deben ser entre el 1 y el %d, por lo que la matriz no es un cuadrado mágico", (n * n));
        retorno = 3;
    }
    return retorno;
}

int imprimeMatriz(int matriz[MAXIMO][MAXIMO], int n) {
    int i = 0;
    int j = 0;
    printf("La matriz es:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d\t", matriz[i][j]);
        }
        printf("\n");
    }
    return 0;
}

int comparaFilas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (i = 0; i < n; i++) {
        comparacion = 0;
        for (j = 0; j < n; j++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la fila %d es %d, por lo que la matriz no es un cuadrado mágico\n", i, comparacion);
            retorno = 4;
            return retorno;
        }
    }
    return retorno;
}

int comparaColumnas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (j = 0; j < n; j++) {
        comparacion = 0;
        for (i = 0; i < n; i++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la columna %d es %d, por lo que la matriz no es un cuadrado mágico\n", j, comparacion);
            retorno = 5;
            return retorno;
        }
    }
    return retorno;
}

int comparaDiagonales(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    comparacion = 0;
    for (i = 0, j = 0; i < n; i++, j++) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la primera diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 6;
        return retorno;
    }

    comparacion = 0;
    for (i = 0, j = (n - 1); i < n; i++, j--) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la segunda diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 7;
        return retorno;
    }
    return retorno;
}

main.c

matriz.h

Cuadrado mágico

#include <stdio.h>
#include "matriz.h"

int main()
{
	int n=0;
	int suma=0;
	int numero=0;
	int matriz[MAXIMO][MAXIMO]= {};
	int i=0;
	int j=0;
	int retorno=0;

	printf("Ingrese un número entre 3 y %d: ", MAXIMO);
	scanf("%d", &n);
	retorno=revisaRango(n,3,MAXIMO);
	if (retorno!=0)
	{
		return retorno;
	}

	suma = obtenSuma(n);
	printf("La suma de cada fila, columna y diagonal debe ser %d para que la matriz sea un cuadrado mágico\n", suma);

	for(i=0; i<n; i++)
	{
		for(j=0; j<n; j++)
		{
			printf("Ingrese el número correspondiente a la fila %d y columna %d: ", i, j);
			scanf("%d", &numero);
			retorno=revisaValorCorrecto(numero, n);
			if (retorno==0)
			{
				matriz[i][j] = numero;
			}
			else
			{
				return retorno;
			}
		}
	}

	imprimeMatriz(matriz, n);

	retorno = comparaFilas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaColumnas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaDiagonales(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	printf("La matriz es un cuadrado mágico");
	return retorno;
}

Ejemplo 2

#define MAXIMO 10

int revisaRango(int n, int min, int max) {
    int retorno = 0;
    if (n < 3) {
        printf("El número ingresado es menor a 3");
        retorno = 1;
    }
    if (n > MAXIMO) {
        printf("El número ingresado es mayor que %d", MAXIMO);
        retorno = 2;
    }
    return retorno;
}

int obtenSuma(int n) {
    return ((n * n) * ((n * n) + 1)) / (2 * n);
}

int revisaValorCorrecto(int numero, int n) {
    int retorno = 0;
    if ((numero < 1) || (numero > (n * n))) {
        printf("Los números de un cuadrado mágico deben ser entre el 1 y el %d, por lo que la matriz no es un cuadrado mágico", (n * n));
        retorno = 3;
    }
    return retorno;
}

int imprimeMatriz(int matriz[MAXIMO][MAXIMO], int n) {
    int i = 0;
    int j = 0;
    printf("La matriz es:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d\t", matriz[i][j]);
        }
        printf("\n");
    }
    return 0;
}

int comparaFilas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (i = 0; i < n; i++) {
        comparacion = 0;
        for (j = 0; j < n; j++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la fila %d es %d, por lo que la matriz no es un cuadrado mágico\n", i, comparacion);
            retorno = 4;
            return retorno;
        }
    }
    return retorno;
}

int comparaColumnas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (j = 0; j < n; j++) {
        comparacion = 0;
        for (i = 0; i < n; i++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la columna %d es %d, por lo que la matriz no es un cuadrado mágico\n", j, comparacion);
            retorno = 5;
            return retorno;
        }
    }
    return retorno;
}

int comparaDiagonales(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    comparacion = 0;
    for (i = 0, j = 0; i < n; i++, j++) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la primera diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 6;
        return retorno;
    }

    comparacion = 0;
    for (i = 0, j = (n - 1); i < n; i++, j--) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la segunda diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 7;
        return retorno;
    }
    return retorno;
}

main.c

matriz.h

Cuadrado mágico

#include <stdio.h>
#include "matriz.h"

int main()
{
	int n=0;
	int suma=0;
	int numero=0;
	int matriz[MAXIMO][MAXIMO]= {};
	int i=0;
	int j=0;
	int retorno=0;

	printf("Ingrese un número entre 3 y %d: ", MAXIMO);
	scanf("%d", &n);
	retorno=revisaRango(n,3,MAXIMO);
	if (retorno!=0)
	{
		return retorno;
	}

	suma = obtenSuma(n);
	printf("La suma de cada fila, columna y diagonal debe ser %d para que la matriz sea un cuadrado mágico\n", suma);

	for(i=0; i<n; i++)
	{
		for(j=0; j<n; j++)
		{
			printf("Ingrese el número correspondiente a la fila %d y columna %d: ", i, j);
			scanf("%d", &numero);
			retorno=revisaValorCorrecto(numero, n);
			if (retorno==0)
			{
				matriz[i][j] = numero;
			}
			else
			{
				return retorno;
			}
		}
	}

	imprimeMatriz(matriz, n);

	retorno = comparaFilas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaColumnas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaDiagonales(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	printf("La matriz es un cuadrado mágico");
	return retorno;
}

Ejemplo 2

#define MAXIMO 10

int revisaRango(int n, int min, int max) {
    int retorno = 0;
    if (n < 3) {
        printf("El número ingresado es menor a 3");
        retorno = 1;
    }
    if (n > MAXIMO) {
        printf("El número ingresado es mayor que %d", MAXIMO);
        retorno = 2;
    }
    return retorno;
}

int obtenSuma(int n) {
    return ((n * n) * ((n * n) + 1)) / (2 * n);
}

int revisaValorCorrecto(int numero, int n) {
    int retorno = 0;
    if ((numero < 1) || (numero > (n * n))) {
        printf("Los números de un cuadrado mágico deben ser entre el 1 y el %d, por lo que la matriz no es un cuadrado mágico", (n * n));
        retorno = 3;
    }
    return retorno;
}

int imprimeMatriz(int matriz[MAXIMO][MAXIMO], int n) {
    int i = 0;
    int j = 0;
    printf("La matriz es:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d\t", matriz[i][j]);
        }
        printf("\n");
    }
    return 0;
}

int comparaFilas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (i = 0; i < n; i++) {
        comparacion = 0;
        for (j = 0; j < n; j++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la fila %d es %d, por lo que la matriz no es un cuadrado mágico\n", i, comparacion);
            retorno = 4;
            return retorno;
        }
    }
    return retorno;
}

int comparaColumnas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (j = 0; j < n; j++) {
        comparacion = 0;
        for (i = 0; i < n; i++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la columna %d es %d, por lo que la matriz no es un cuadrado mágico\n", j, comparacion);
            retorno = 5;
            return retorno;
        }
    }
    return retorno;
}

int comparaDiagonales(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    comparacion = 0;
    for (i = 0, j = 0; i < n; i++, j++) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la primera diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 6;
        return retorno;
    }

    comparacion = 0;
    for (i = 0, j = (n - 1); i < n; i++, j--) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la segunda diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 7;
        return retorno;
    }
    return retorno;
}

main.c

matriz.h

Cuadrado mágico

#include <stdio.h>
#include "matriz.h"

int main()
{
	int n=0;
	int suma=0;
	int numero=0;
	int matriz[MAXIMO][MAXIMO]= {};
	int i=0;
	int j=0;
	int retorno=0;

	printf("Ingrese un número entre 3 y %d: ", MAXIMO);
	scanf("%d", &n);
	retorno=revisaRango(n,3,MAXIMO);
	if (retorno!=0)
	{
		return retorno;
	}

	suma = obtenSuma(n);
	printf("La suma de cada fila, columna y diagonal debe ser %d para que la matriz sea un cuadrado mágico\n", suma);

	for(i=0; i<n; i++)
	{
		for(j=0; j<n; j++)
		{
			printf("Ingrese el número correspondiente a la fila %d y columna %d: ", i, j);
			scanf("%d", &numero);
			retorno=revisaValorCorrecto(numero, n);
			if (retorno==0)
			{
				matriz[i][j] = numero;
			}
			else
			{
				return retorno;
			}
		}
	}

	imprimeMatriz(matriz, n);

	retorno = comparaFilas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaColumnas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaDiagonales(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	printf("La matriz es un cuadrado mágico");
	return retorno;
}

Ejemplo 2

#define MAXIMO 10

int revisaRango(int n, int min, int max) {
    int retorno = 0;
    if (n < 3) {
        printf("El número ingresado es menor a 3");
        retorno = 1;
    }
    if (n > MAXIMO) {
        printf("El número ingresado es mayor que %d", MAXIMO);
        retorno = 2;
    }
    return retorno;
}

int obtenSuma(int n) {
    return ((n * n) * ((n * n) + 1)) / (2 * n);
}

int revisaValorCorrecto(int numero, int n) {
    int retorno = 0;
    if ((numero < 1) || (numero > (n * n))) {
        printf("Los números de un cuadrado mágico deben ser entre el 1 y el %d, por lo que la matriz no es un cuadrado mágico", (n * n));
        retorno = 3;
    }
    return retorno;
}

int imprimeMatriz(int matriz[MAXIMO][MAXIMO], int n) {
    int i = 0;
    int j = 0;
    printf("La matriz es:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d\t", matriz[i][j]);
        }
        printf("\n");
    }
    return 0;
}

int comparaFilas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (i = 0; i < n; i++) {
        comparacion = 0;
        for (j = 0; j < n; j++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la fila %d es %d, por lo que la matriz no es un cuadrado mágico\n", i, comparacion);
            retorno = 4;
            return retorno;
        }
    }
    return retorno;
}

int comparaColumnas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (j = 0; j < n; j++) {
        comparacion = 0;
        for (i = 0; i < n; i++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la columna %d es %d, por lo que la matriz no es un cuadrado mágico\n", j, comparacion);
            retorno = 5;
            return retorno;
        }
    }
    return retorno;
}

int comparaDiagonales(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    comparacion = 0;
    for (i = 0, j = 0; i < n; i++, j++) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la primera diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 6;
        return retorno;
    }

    comparacion = 0;
    for (i = 0, j = (n - 1); i < n; i++, j--) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la segunda diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 7;
        return retorno;
    }
    return retorno;
}

main.c

matriz.h

Cuadrado mágico

#include <stdio.h>
#include "matriz.h"

int main()
{
	int n=0;
	int suma=0;
	int numero=0;
	int matriz[MAXIMO][MAXIMO]= {};
	int i=0;
	int j=0;
	int retorno=0;

	printf("Ingrese un número entre 3 y %d: ", MAXIMO);
	scanf("%d", &n);
	retorno=revisaRango(n,3,MAXIMO);
	if (retorno!=0)
	{
		return retorno;
	}

	suma = obtenSuma(n);
	printf("La suma de cada fila, columna y diagonal debe ser %d para que la matriz sea un cuadrado mágico\n", suma);

	for(i=0; i<n; i++)
	{
		for(j=0; j<n; j++)
		{
			printf("Ingrese el número correspondiente a la fila %d y columna %d: ", i, j);
			scanf("%d", &numero);
			retorno=revisaValorCorrecto(numero, n);
			if (retorno==0)
			{
				matriz[i][j] = numero;
			}
			else
			{
				return retorno;
			}
		}
	}

	imprimeMatriz(matriz, n);

	retorno = comparaFilas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaColumnas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaDiagonales(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	printf("La matriz es un cuadrado mágico");
	return retorno;
}

Ejemplo 2

#define MAXIMO 10

int revisaRango(int n, int min, int max) {
    int retorno = 0;
    if (n < 3) {
        printf("El número ingresado es menor a 3");
        retorno = 1;
    }
    if (n > MAXIMO) {
        printf("El número ingresado es mayor que %d", MAXIMO);
        retorno = 2;
    }
    return retorno;
}

int obtenSuma(int n) {
    return ((n * n) * ((n * n) + 1)) / (2 * n);
}

int revisaValorCorrecto(int numero, int n) {
    int retorno = 0;
    if ((numero < 1) || (numero > (n * n))) {
        printf("Los números de un cuadrado mágico deben ser entre el 1 y el %d, por lo que la matriz no es un cuadrado mágico", (n * n));
        retorno = 3;
    }
    return retorno;
}

int imprimeMatriz(int matriz[MAXIMO][MAXIMO], int n) {
    int i = 0;
    int j = 0;
    printf("La matriz es:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d\t", matriz[i][j]);
        }
        printf("\n");
    }
    return 0;
}

int comparaFilas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (i = 0; i < n; i++) {
        comparacion = 0;
        for (j = 0; j < n; j++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la fila %d es %d, por lo que la matriz no es un cuadrado mágico\n", i, comparacion);
            retorno = 4;
            return retorno;
        }
    }
    return retorno;
}

int comparaColumnas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (j = 0; j < n; j++) {
        comparacion = 0;
        for (i = 0; i < n; i++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la columna %d es %d, por lo que la matriz no es un cuadrado mágico\n", j, comparacion);
            retorno = 5;
            return retorno;
        }
    }
    return retorno;
}

int comparaDiagonales(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    comparacion = 0;
    for (i = 0, j = 0; i < n; i++, j++) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la primera diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 6;
        return retorno;
    }

    comparacion = 0;
    for (i = 0, j = (n - 1); i < n; i++, j--) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la segunda diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 7;
        return retorno;
    }
    return retorno;
}

main.c

matriz.h

Cuadrado mágico

#include <stdio.h>
#include "matriz.h"

int main()
{
	int n=0;
	int suma=0;
	int numero=0;
	int matriz[MAXIMO][MAXIMO]= {};
	int i=0;
	int j=0;
	int retorno=0;

	printf("Ingrese un número entre 3 y %d: ", MAXIMO);
	scanf("%d", &n);
	retorno=revisaRango(n,3,MAXIMO);
	if (retorno!=0)
	{
		return retorno;
	}

	suma = obtenSuma(n);
	printf("La suma de cada fila, columna y diagonal debe ser %d para que la matriz sea un cuadrado mágico\n", suma);

	for(i=0; i<n; i++)
	{
		for(j=0; j<n; j++)
		{
			printf("Ingrese el número correspondiente a la fila %d y columna %d: ", i, j);
			scanf("%d", &numero);
			retorno=revisaValorCorrecto(numero, n);
			if (retorno==0)
			{
				matriz[i][j] = numero;
			}
			else
			{
				return retorno;
			}
		}
	}

	imprimeMatriz(matriz, n);

	retorno = comparaFilas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaColumnas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaDiagonales(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	printf("La matriz es un cuadrado mágico");
	return retorno;
}

Ejemplo 2

#define MAXIMO 10

int revisaRango(int n, int min, int max) {
    int retorno = 0;
    if (n < 3) {
        printf("El número ingresado es menor a 3");
        retorno = 1;
    }
    if (n > MAXIMO) {
        printf("El número ingresado es mayor que %d", MAXIMO);
        retorno = 2;
    }
    return retorno;
}

int obtenSuma(int n) {
    return ((n * n) * ((n * n) + 1)) / (2 * n);
}

int revisaValorCorrecto(int numero, int n) {
    int retorno = 0;
    if ((numero < 1) || (numero > (n * n))) {
        printf("Los números de un cuadrado mágico deben ser entre el 1 y el %d, por lo que la matriz no es un cuadrado mágico", (n * n));
        retorno = 3;
    }
    return retorno;
}

int imprimeMatriz(int matriz[MAXIMO][MAXIMO], int n) {
    int i = 0;
    int j = 0;
    printf("La matriz es:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d\t", matriz[i][j]);
        }
        printf("\n");
    }
    return 0;
}

int comparaFilas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (i = 0; i < n; i++) {
        comparacion = 0;
        for (j = 0; j < n; j++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la fila %d es %d, por lo que la matriz no es un cuadrado mágico\n", i, comparacion);
            retorno = 4;
            return retorno;
        }
    }
    return retorno;
}

int comparaColumnas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (j = 0; j < n; j++) {
        comparacion = 0;
        for (i = 0; i < n; i++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la columna %d es %d, por lo que la matriz no es un cuadrado mágico\n", j, comparacion);
            retorno = 5;
            return retorno;
        }
    }
    return retorno;
}

int comparaDiagonales(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    comparacion = 0;
    for (i = 0, j = 0; i < n; i++, j++) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la primera diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 6;
        return retorno;
    }

    comparacion = 0;
    for (i = 0, j = (n - 1); i < n; i++, j--) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la segunda diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 7;
        return retorno;
    }
    return retorno;
}

main.c

matriz.h

Cuadrado mágico

#include <stdio.h>
#include "matriz.h"

int main()
{
	int n=0;
	int suma=0;
	int numero=0;
	int matriz[MAXIMO][MAXIMO]= {};
	int i=0;
	int j=0;
	int retorno=0;

	printf("Ingrese un número entre 3 y %d: ", MAXIMO);
	scanf("%d", &n);
	retorno=revisaRango(n,3,MAXIMO);
	if (retorno!=0)
	{
		return retorno;
	}

	suma = obtenSuma(n);
	printf("La suma de cada fila, columna y diagonal debe ser %d para que la matriz sea un cuadrado mágico\n", suma);

	for(i=0; i<n; i++)
	{
		for(j=0; j<n; j++)
		{
			printf("Ingrese el número correspondiente a la fila %d y columna %d: ", i, j);
			scanf("%d", &numero);
			retorno=revisaValorCorrecto(numero, n);
			if (retorno==0)
			{
				matriz[i][j] = numero;
			}
			else
			{
				return retorno;
			}
		}
	}

	imprimeMatriz(matriz, n);

	retorno = comparaFilas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaColumnas(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	retorno = comparaDiagonales(matriz, n, suma);
	if (retorno!=0)
	{
		return retorno;
	}

	printf("La matriz es un cuadrado mágico");
	return retorno;
}

Ejemplo 2

#define MAXIMO 10

int revisaRango(int n, int min, int max) {
    int retorno = 0;
    if (n < 3) {
        printf("El número ingresado es menor a 3");
        retorno = 1;
    }
    if (n > MAXIMO) {
        printf("El número ingresado es mayor que %d", MAXIMO);
        retorno = 2;
    }
    return retorno;
}

int obtenSuma(int n) {
    return ((n * n) * ((n * n) + 1)) / (2 * n);
}

int revisaValorCorrecto(int numero, int n) {
    int retorno = 0;
    if ((numero < 1) || (numero > (n * n))) {
        printf("Los números de un cuadrado mágico deben ser entre el 1 y el %d, por lo que la matriz no es un cuadrado mágico", (n * n));
        retorno = 3;
    }
    return retorno;
}

int imprimeMatriz(int matriz[MAXIMO][MAXIMO], int n) {
    int i = 0;
    int j = 0;
    printf("La matriz es:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d\t", matriz[i][j]);
        }
        printf("\n");
    }
    return 0;
}

int comparaFilas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (i = 0; i < n; i++) {
        comparacion = 0;
        for (j = 0; j < n; j++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la fila %d es %d, por lo que la matriz no es un cuadrado mágico\n", i, comparacion);
            retorno = 4;
            return retorno;
        }
    }
    return retorno;
}

int comparaColumnas(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    for (j = 0; j < n; j++) {
        comparacion = 0;
        for (i = 0; i < n; i++) {
            comparacion += matriz[i][j];
        }
        if (comparacion != suma) {
            printf("La suma de la columna %d es %d, por lo que la matriz no es un cuadrado mágico\n", j, comparacion);
            retorno = 5;
            return retorno;
        }
    }
    return retorno;
}

int comparaDiagonales(int matriz[MAXIMO][MAXIMO], int n, int suma) {
    int i = 0;
    int j = 0;
    int comparacion = 0;
    int retorno = 0;

    comparacion = 0;
    for (i = 0, j = 0; i < n; i++, j++) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la primera diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 6;
        return retorno;
    }

    comparacion = 0;
    for (i = 0, j = (n - 1); i < n; i++, j--) {
        comparacion += matriz[i][j];
    }
    if (comparacion != suma) {
        printf("La suma de la segunda diagonal es %d, por lo que la matriz no es un cuadrado mágico\n", comparacion);
        retorno = 7;
        return retorno;
    }
    return retorno;
}

main.c

matriz.h

Programación estructurada: Diseño modular

By Gilberto 🦁

Programación estructurada: Diseño modular

Diseño modular

  • 156

More from Gilberto 🦁