Los sdkn

UNIVERSIDAD CENTRAL DEL ECUADOR
INGENIERÍA MATEMÁTICA
PROGRAMACIÓN I
PROYECTO:
MATRIZ MÁGICA
INTEGRANTES:
 ÁGREDA STEFANY
 BRAVO KEVIN
 CHICAIZA NATHALY
 CHUQUILLA DARÍO
QUITO, 08 DE JULIO DEL 2015

Matriz Mágica
2
ÍNDICE
ÍNDICE............................................................................................................................................2
TABLA DE ILUSTRACIONES........................................................................................................2
RESUMEN.......................................................................................................................................3
CAPÍTULO I....................................................................................................................................4
EL PROBLEMA...........................................................................................................................4
PLANTEAMIENTO DEL PROBLEMA...................................................................................4
OBJETIVOS.............................................................................................................................5
JUSTIFICACIÓN .....................................................................................................................6
CAPÍTULO II ..................................................................................................................................7
MARCO TEÓRICO .....................................................................................................................7
MATRIZ...................................................................................................................................7
CÓDIGO EN VISUAL BASIC: ..................................................................................................14
CÓDIGO EN C:..........................................................................................................................19
CÓDIGO JAVA:.........................................................................................................................24
RECOMENDACIONES.................................................................................................................29
BIBLIOGRAFÍA............................................................................................................................30
TABLA DE ILUSTRACIONES
ILUSTRACIÓN 1: MATRIZ .............................................................................................................. 7
ILUSTRACIÓN 2: MATRIZ MONTOS................................................................................................ 9
ILUSTRACIÓN 3 MATRIZ MÁGICA ................................................................................................ 10
ILUSTRACIÓN 4: ARREGLO DE DATOS......................................................................................... 10
ILUSTRACIÓN 5: ENTRADAS YSALIDAS DEL ALGORITMO .......................................................... 11

Matriz Mágica
3
RESUMEN
Todas las personas debemos conocer el concepto de una matriz para poder organizar nuestra
información, pero para ello debe generarse la intención de aprender. En programación se busca
tratar de mejorar y facilitar procesos de nuestra vida cotidiana como lo es problemas de
razonamientos matemáticos, por lo cual en nuestro trabajo se presentará un algoritmo que nos
ayude a realizar procesos matemáticos los mismos que indicarán si una matriz que ingresamos es
mágica o no mediante la verificación de la suma de sus filas y columnas pero siempre teniendo en
cuenta que una matriz mágica es una matriz cuadrada.

Matriz Mágica
4
CAPÍTULO I
EL PROBLEMA
PLANTEAMIENTO DEL PROBLEMA
La resolución de problemas matemáticos como lo es de una matriz en el ámbito académico
es de mucha importancia la cual se origina al querer tener datos más ordenados en filas y columnas
para que la presentación de la información sea más clara, entendible y estética, a medida que el
conocimiento va avanzando no solo se la utiliza en matemática sino que también en diversas áreas
derivadas de ella por la cual en la actualidad todo ser humano conoce el concepto de lo que es una
matriz.
La utilización de matrices constituye actualmente una parte esencial en los lenguajes de
programación, ya que la mayoría de los datos se introducen en los ordenadores como tablas
organizadas en filas y columnas: hojas de cálculo, bases de datos, etc. También son utilizadas para
resolver problemas matemáticos, por ejemplo en la resolución de sistemas de ecuaciones lineales,
de las ecuaciones diferenciales y de las derivadas parciales.
Con el estudio de lo que es un matriz se podrá resolver una matriz realizada con bases de
los conceptos que se van estudiar en la cual también se verificará si es mágica (Una matriz mágica
es una matriz cuadrada (tiene igual número de filas que de columnas) que tiene como propiedad
especial que la suma de las filas, las columnas y las diagonales es igual) o no lo es; mediante la
suma de sus filas, columnas y diagonales la misma que permitirá que los usuarios que la utilicen
se den cuenta la diferencia entre las dos matrices que podrán generar.
El concepto de matrices ha ayudado a ordenar y resolver diversos problemas de la vida real
por lo que su estudio es de gran importancia siendo esta la que ayudará en el presente proyecto a
resolver el objetivo propuesto.
Con la ayuda de un algoritmo se podrá generar la solución de la matriz mágica el mismo
que será realizado en tres diferentes lenguajes de programación los cuales son Visual Basic, C++
y Java, estos lenguajes presentarán un mismo algoritmo pero con características diferentes en sus
lenguajes de códigos e interpretación de los mismos.

Matriz Mágica
5
OBJETIVOS
Objetivo General:
 Aprender y analizar el concepto de matrices en programación para realizar algoritmos
con las mismas que permitan dar solución a varios problemas, entre ellas la respuesta de
una matriz mágica.
Objetivos Específicos:
 Conocer que es una matriz.
 Representar conjuntos de datos mediante matrices.
 Solucionar problemas utilizando matrices.

Matriz Mágica
6
JUSTIFICACIÓN
El presente trabajo realizado por el grupo DSKN es de gran importancia ya que con este se
pretende dar solución a diversos problemas cotidianos mediante la utilización básica de conceptos
de matrices.
Los aspectos novedosos a investigarse en el presente trabajo es como realizar sumas de
filas, columnas y diagonales dentro de una matriz para con ello poder determinar si la matriz que
propone el usuario va a ser mágica o no.
Al ser este una investigación interesante y distractora tendrá gran acogida puesto que es
fácil de utilizarla solo se necesita la imaginación y habilidad del usuario para digitar los números
y así poder comprobar si lo que intenta hacer corresponde a la matriz mágica, una matriz de igual
número de filas y columnas cabe recalcar.
El uso más importante de las matrices es para resolver ecuaciones lineales de muchas
variables en forma sistemática y compacta. (Esto incluye problemas de física de muchos cuerpos
y cualquier aproximación lineal de un problema no lineal).
También se pueden crear las llamadas "matrices de transición" que son matrices que
describen procesos de transición de estados cuánticos.

Matriz Mágica
7
CAPÍTULO II
MARCO TEÓRICO
MATRIZ
(CALDAS, s.f.) Una matriz es una estructura de datos, o más técnicamente, un espacio de memoria
que permite almacenar una colección de elementos, todos del mismo tipo. La diferencia con los
arreglos está en que, en las matrices, los elementos no están organizados linealmente sino que su
organización es bidimensional, es decir, en filas y columnas. Conviene imaginar una matriz como
una organización de celdas de memoria, o casillas, en cada una de las cuales se puede guardar un
elemento de la colección. Además, es usual dibujarla como lo ilustra la figura siguiente:
Ilustración 1: Matriz
Esta figura representa un matriz de cuatro filas (numeradas verticalmente de 0 a 3) y seis columnas
(numeradas horizontalmente de 0 a 5). En cada una de las 24 celdas o casillas se puede guardar un
dato. La dimensión o tamaño de una matriz es el número filas por el número de columnas. Debe
ser claro entonces que la figura anterior es la gráfica de una matriz de dimensión 4x6.
La numeración de las filas y las columnas determina que cada una de las casillas de una matriz
tiene asociados dos números que la identifican de manera única. A estos números se les llama
Matrices 3 índice de fila e índice de columna, respectivamente. En el seudocódigo, y también en
C y C++, las filas y las columnas se numeran desde 0.
Los lenguajes como C y C++, permiten que el programador declare matrices de cualquier tipo y
prácticamente de cualquier tamaño. En el seudocódigo, un matriz se declara usando el siguiente
formato:
En este formato aparecen en mayúsculas y entre los caracteres < y > los componentes que el
programador puede determinar. Así por ejemplo, si se quiere declarar una matriz con

Matriz Mágica
8
nombre mat, de dimensión 15x4 y que pueda almacenar datos de tipo caracter, se debe escribir la
siguiente línea.
Según el formato anterior, el programador debe bautizar la matriz (ponerle un nombre
significativo), debe decir cuál es su dimensión, y también debe decir de qué tipo son los elementos
que almacenará.
Enseguida se dan algunos ejemplos de declaraciones de matrices.
 Si se necesita guardar la información relacionada con el tablero de un juego de tic tac toe
(el tradicional triqui), se puede declarar la siguiente matriz:
tablero : matriz [3][3] de caracter
 Si se requiere guardar las notas que han sacado 35 estudiantes en los 5 talleres y en los 5
laboratorios del curso de Programación de Computadores se pueden declarar las
siguientes matrices.
talleres : matriz [35][5] de real
laboratorios : matriz [35][5] de real
Note que, en ambas matrices, cada fila guarda las notas de un estudiante del curso.
 Si se quiere guardar las letras que conforman una sopa de letras, como aquellas que vienen
en los pasatiempos, se puede declarar la siguiente matriz.
sopa : matriz [10][15] de carácter
Note que la sopa de letras más grande que se puede guardar es de 10 filas por 15 columnas. Los
índices se crearon para permitir que el programador se pueda referir, de forma específica y directa,
a una cualquiera de las casillas de la matriz, tanto para guardar un dato en esa casilla, como para
obtener el dato almacenado en ella. En el seudocódigo, para referirse a una casilla particular de
una matriz se debe seguir el siguiente formato:
Es decir, se debe escribir el nombre de la matriz seguido por el índice de fila y por el índice de
columna, ambos entre paréntesis cuadrados, de la casilla que se quiere consultar.
Para los siguientes ejemplos, suponga que se declara la matriz montos, de la siguiente manera:
montos : matriz [6][10] de real

Matriz Mágica
9
 La siguiente instrucción asigna o guarda el número 10,4 en la casilla de la esquina superior
izquierda de esta matriz:
montos [0][0]:= 10,4
 La siguiente instrucción iterativa guarda 5,5 en cada una de las casillas de la última fila de
esta matriz:
k:=0
MIENTRAS (k<10) HACER
montos[5][k]:= 5,5
k:=k+1
FIN‐MIENTRAS
La siguiente figura muestra la matriz montos después de ejecutadas las instrucciones de los dos
ejemplos anteriores. Las casillas vacías no tienen valores definidos.
Ilustración 2: Matriz montos
(Microsoft, s.f.) Una matriz tiene las propiedades siguientes:
 Una matriz puede ser unidimensional, multidimensional o escalonada.
 El número de dimensiones y la longitud de cada dimensión se establecen cuando se crea la
instancia de la matriz. Estos valores no se pueden cambiar durante la duración de la
instancia.
 Los valores predeterminado de los elementos numéricos de matriz se establece en cero y
el de los elementos de referencia se establece en null.
 Una matriz escalonada es una matriz de matrices y por consiguiente sus elementos son
tipos de referencia y se inicializan en null.
 Las matrices se indizan basadas en cero: una matriz con n elementos se indiza
desde 0 hasta n-1.
 Los elementos de una matriz pueden ser de cualquier tipo, incluido el tipo matriz.

Matriz Mágica
10
MATRIZ MÁGICA
(Matriz mágica, s.f.) Una matriz mágica es una matriz cuadrada (tiene igual número de filas que
de columnas) que tiene como propiedad especial que la suma de las filas, las columnas y las
diagonales es igual. Por ejemplo:
Ilustración 3 Matriz mágica
En esta matriz las sumas son 15.
Considere el problema de construir un algoritmo que compruebe si una matriz de datos enteros es
mágica o no, y en caso de que sea mágica escribir la suma. El usuario ingresa el tamaño de la
matriz máximo hasta 10. Además debe guardar la suma de las filas, las columnas y las diagonales
en un arreglo en el orden siguiente:
Ilustración 4: Arreglo de datos
Las entradas (datos conocidos) para el algoritmo son:
La dimensión de la matriz
Los números que contiene la matriz
La salida esperada (datos desconocidos) es:
La matriz es mágica o no, y si es mágica cuál es el valor de la suma.
En este problema, los arreglos son útiles para guardar los datos que conforman la matriz. Los
números que contiene la matriz se pueden guardar en una variable entera. La siguiente gráfica
resume las entradas y salidas del algoritmo que se pretende diseñar. Además bautizan todas las
variables mencionadas.

Matriz Mágica
11
Ilustración 5: Entradas y Salidas del Algoritmo
Las condiciones iniciales y finales se pueden expresar mediante las cláusulas REQUIERE y
GARANTIZA:
REQUIERE: La dimensión de la matriz que debe ser máximo 10x10 Cada elemento de la matriz
debe ser un número entero
GARANTIZA Muestra en pantalla si es mágica o no, y si lo es cuál es el valor de la suma.
ALGORITMO EN PSEUDOCÓDIGO
Una primera versión del algoritmo puede ser la siguiente:
Inicio
Paso 1. Leer el tamaño de la matriz
Paso 2. Leer los elementos de la matriz
Paso 3. Determinar si la matriz es mágica o no
Paso 4. Si la matriz es mágica mostrar el valor de la suma
Fin
Los pasos 1 y 2 son interacciones con el usuario que permiten capturar los datos de entrada. La
versión inicial se puede refinar detallando estos pasos y además defiendo las variables para
hacerlos:
Procedimiento principal
variables i, j, cont, dimension, suma: entero //i señala las filas
//j señala las columnas
magica: matriz [10][10] de enteros
Inicio
escribir(“Por favor digite la dimensión con la que desea trabajar: ”)
leer(dimension)
para (i=0 hasta dimension-1) hacer
para(j=0 hasta dimension -1) hacer

Matriz Mágica
12
escribir(“Por favor digite el dato en la posición”)
escribir(i, j)
leer(magica[i][j])
fin_para
fin_para
Paso 3
Paso 4
Se puede observar que el primer ciclo para tiene como contador la variable i, esto indica que se
llenará la matriz por filas, el segundo ciclo para que tiene como contador la variable j, recorrerá la
fila columna a columna para ubicar allí el dato correspondiente. La parte nuclear de la solución es
el paso 3. En este problema en particular se sabe que el número de filas y de columnas es igual y
que hay dos diagonales. Para el ejemplo mostrado al inicio sería 3 filas, 3 columnas y dos
diagonales. Para almacenar las sumas en un arreglo este tendrá una dimensión de 2*tam+2. La
declaración del arreglo sumas es: sumas: arreglo [22] de enteros Ahora para calcular las sumas se
puede hacer lo siguiente: Paso 3.1: Inicializar el arreglo de sumas en cero Paso 3.2: Sumar fila por
fila, columna por columna y las diagonales y guardar su valor en el arreglo.
para(i=0 hasta 2*dimension+2) hacer
sumas[i]:=0
fin_para
//Sumas correspondientes a las filas
para(i=0 hasta dimension -1) hacer
sumas[i] =magica[i][j] +sumas[i]
fin_para
fin_para
//Sumas correspondientes a las columnas
sumas[j+ dimension]=magica[i][j]+sumas[j+ dimension]
fin_para
fin_para
//Sumas correspondientes a las diagonales
sumas[2* dimension]=magica[i][i]+sumas[2* dimension]
fin_para
sumas[2* dimension +1]=magica[i][( dimension -1)-i]+sumas[2* dimension +1];
fin_para
Paso 4: Para determinar si la matriz es mágica se va a recorrer y comparar el vector sumas, si en
algún momento se encuentra un valor diferente se muestra en pantalla que la matriz no es mágica
y se lleva el contador i más allá del final del arreglo, si por el contrario se llega al final del arreglo,

Matriz Mágica
13
es decir que todo este contiene el mismo valor y la matriz si cumple con las características
evaluadas, se muestra en pantalla que la matriz es mágica.
//Comparar el vector suma y muestra el resultado
int con=0;
con=sumas[0];
para(i=1 hasta 2* dimension +1) hacer
si(con<>sumas[i])
escribir("la matriz no es mágica)
i=2* dimension +3;
fin_si
fin-para
si(i=2* dimension +2)
escribir(“la matriz es mágica y la suma es:”)
escribir(con);
fin_si
El algoritmo completo se presenta enseguida.
Procedimiento principal
variables
i, j, aux, dimension, suma: entero //i señala las filas
//j señala las columnas
con=0: entero
magica: matriz [10][10] de enteros
sumas: arreglo [22] de enteros
Inicio
escribir(“Por favor digite la dimensión con la que desea trabajar: ”)
leer(dimension)
para (i=0 hasta dimension -1) hacer
escribir(“Por favor digite el dato en la posición”)
escribir(i,j)
leer(magica[i][j])
fin_para
fin_para
sumas[i]:=0
fin_para
//Sumas correspondientes a las filas
sumas[i]=magica[i][j]+sumas[i]

Matriz Mágica
14
fin_para
fin_para
//Sumas correspondientes a las columnas
sumas[j+ dimension]=magica[i][j]+sumas[j+ dimension]
fin_para
fin_para
//Sumas correspondientes a las diagonales
sumas[2* dimension]=magica[i][i]+sumas[2* dimension]
fin_para
sumas[2* dimension +1]=magica[i][( dimension -1)-i]+sumas[2* dimension +1];
fin_para
con=sumas[0];
si(con<>sumas[i])
escribir("la matriz no es mágica)
i=2* dimension +3;
fin_si
fin-para
si(i=2* dimension +2)
escribir(“la matriz es mágica y la suma es:”)
escribir(con);
fin_si
fin-procedimiento
CÓDIGO EN VISUAL BASIC:
1. Definiremos las variables q vamos a necesitar:
Dim i As Integer
Dim j As Integer
Dim aux As Integer
Dim dimension As Integer
Dim cont As Integer
Dim Matriz(10, 10) As Integer
Dim suma(300) As Integer
2. Desplegaremos el siguiente mensaje:
dimension = InputBox("Porfavor ingrese la dimension de la matriz con la que desea trabajar ")
3. Ciclo para generar la matriz:

Matriz Mágica
15
For i = 0 To dimension - 1
For j = 0 To dimension - 1
Matriz(i, j) = InputBox("Digite los elementos de la matriz en la posicion: " & i & "." & j)
Next j
Next i
4. Impresión de datos:
Worksheets("Hoja1").Cells(1, 2).Value = ("PROYECTO DE MATRIZ MÁGICA ")
Worksheets("Hoja1").Cells(3, 2).Value = ("La matriz es: ")
Cells(3, 2).Interior.ColorIndex = 39
Cells(3, 2).BorderAround (xlContinuous)
Cells(3, 2).BorderAround (xlHairline)
Worksheets("Hoja1").Cells(4 + i, 2 + j).Value = (Matriz(i, j))
Cells(4 + i, 2 + j).Interior.ColorIndex = 40
Cells(4 + i, 2 + j).BorderAround (xlContinuous)
Cells(4 + i, 2 + j).BorderAround (xlHairline)
Next j
Next i
5. Suma filas:
For i = 0 To 2 * dimension + 2
suma(i) = 0
Next i
'Suma Filas
Worksheets("Hoja1").Cells(9, 1).Value = ("La suma de sus filas es: ")
Worksheets("Hoja1").Cells(10 + i, 1).Value = ("Suma fila " & i + 1)
Cells(10 + i, 1).Interior.ColorIndex = 44
Cells(10 + i, 1).BorderAround (xlContinuous)
Cells(10 + i, 1).BorderAround (xlHairline)
suma(i) = suma(i) + Matriz(i, j)
Worksheets("Hoja1").Cells(10 + i, 2 + j).Value = (suma(i))
Next j

Matriz Mágica
16
Next i
6. Suma columnas:
'Suma Columnas
Worksheets("Hoja1").Cells(15, 1).Value = ("La suma de sus columnas es: ")
suma(j + dimension) = suma(j + dimension) + Matriz(i, j)
Worksheets("Hoja1").Cells(16, 1 + j).Value = ("Suma columna " & j + 1)
Cells(16, 1 + j).Interior.ColorIndex = 44
Cells(16, 1 + j).BorderAround (xlContinuous)
Cells(16, 1 + j).BorderAround (xlHairline)
Worksheets("Hoja1").Cells(17 + i, 1 + j).Value = (suma(j + dimension))
Next i
Next j
7. Suma diagonales:
'Suma Diagonales
j = 0
Worksheets("Hoja1").Cells(21, 1).Value = ("La suma de sus diagonales es: ")
Worksheets("Hoja1").Cells(22, 1).Value = ("Suma diagonal izq-der ")
suma(2 * dimension) = suma(2 * dimension) + Matriz(i, i)
Worksheets("Hoja1").Cells(22 + i, 2 + j).Value = (suma(2 * dimension))
j = j + 1
Next i
Worksheets("Hoja1").Cells(22, j + 2).Value = ("Suma diagonal der-izq ")
Cells(22, j + 2).Interior.ColorIndex = 22
Cells(22, j + 2).BorderAround (xlContinuous)
Cells(22, j + 2).BorderAround (xlHairline)

Matriz Mágica
17
suma(2 * dimension + 1) = suma(2 * dimension + 1) + Matriz(i, (dimension - 1) - i)
Worksheets("Hoja1").Cells(22 + i, 3 + j).Value = (suma(2 * dimension + 1))
j = j + 1
Next i
8. Verificación de la matriz:
'Verificar si la matriz es magica
cont = 0
cont = suma(0)
For i = 1 To 2 * dimension + 1
If (cont = suma(i)) Then
Worksheets("Hoja1").Cells(27, 1).Value = ("La matriz es magica y su suma es " & cont)
Else
If (cont <> suma(i)) Then
Worksheets("Hoja1").Cells(27, 1).Value = ("La matriz no es magica")
End If
End If
Next i
9. Fin del algoritmo:
End Sub
AHORA PROCEDEREMOS A REALIZAR LAS DIFERENTES PRUEBAS Y ASÍ
VERIFICAR LA VALIDEZ DEL ALGORITMO:
*MATRIZ MÁGICA:
1. Ejecutamos el programa:
2. Escogemos la dimensión con la que trabajaremos: (En este caso=4)

Matriz Mágica
18
3. Digitaremos los valores de nuestra matriz de inicio a fin:
4. Estos son los resultados obtenidos:
*MATRIZ NO MÁGICA:
Los pasos 1,2 y 3 serán exactamente iguales, lo que cambiará son los resultados obtenidos:
En el paso 3, los números serán distintos ya que verificaremos una matriz no mágica.
4. Resultados:

Matriz Mágica
19
CÓDIGO EN C:
1. Incluimos las librerías:
#include "stdafx.h"
#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
#include "time.h"
int _tmain(int argc, _TCHAR* argv[])
{
system("color F0");
2. Definimos las variables:
int i, j, aux, dimension, suma[300], cont;
char matriz[10][10];
printf("Porfavor ingrese la dimension de la matriz con la que desea trabajar ");
//srand(time(NULL)); Únicamente se utiliza para generar números aleatorios pero no fue
necesario
scanf_s("%d", &dimension);
for (i = 0; i < dimension; i++)
{
for (j = 0; j < dimension; j++)

Matriz Mágica
20
{
printf("Digite los elementos de la matriz en la posicion %d %d ", i, j);
scanf_s("%d", &matriz[i][j]);
}
printf("nn");
}
{
{
printf("t%d", matriz[i][j]);
}
printf("nn");
}
printf("n");
printf("+++++ Suma de matriz filas +++++");
printf("n");
for (i = 0; i < 2 * dimension + 2; i++)
{
suma[i] = 0;
}
4. Suma filas:
//suma filas
{
{
suma[i] = suma[i] + matriz[i][j];
printf("t %d", suma[i]);
}
printf("nn");
}
printf("n");
printf("+++++ Suma de matriz columnas +++++");
printf("n");
5. Suma columnas:
//suma columnas
{
{
suma[j + dimension] = suma[j + dimension] + matriz[i][j];

Matriz Mágica
21
printf("t %d", suma[j + dimension]);
}
printf("nn");
}
printf("n");
printf("+++++ Suma de matriz diagonales +++++");
printf("n");
6. Suma diagonales:
//suma diagonales
{
suma[2 * dimension] = suma[2 * dimension] + matriz[i][i];
printf("t %d", suma[2 * dimension]);
}
printf("nn");
printf("n");
{
suma[2 * dimension + 1] = suma[2 * dimension + 1] + matriz[i][(dimension - 1) -
i];
printf("t %d", suma[2 * dimension + 1]);
}
printf("nn");
//verificar si la matriz es magica
cont = 0;
cont = suma[0];
{
if ((cont != suma[i]))
{
printf("La matriz no es magica");
i = 2 * dimension + 3;
}
else
if (i = 2 * dimension + 2)
{
printf("La matriz es magica y su suma es %d", cont);
}
}
8. Fin del algoritmo:

Matriz Mágica
22
getchar();
getchar();
return 0;
}
*MATRIZ MÁGICA:
1. Ejecutamos el programa:
2. Escogeremos la dimensión con la que vamos a trabajar: (En este caso =4)
3. Digitaremos los valores de la matriz de inicio a fin:
4. Resultados:

Matriz Mágica
23
*MATRIZ NO MÁGICA:
4. Resultados:

Matriz Mágica
24
CÓDIGO JAVA:
package javaapplication1;
import java.util.*;
public class JavaApplication1 {
public static void main(String[] args)
{
1. Definimos variables:
int i, j, aux, dimension, cont;
Scanner dato=new Scanner(System.in);
2. Desplegamos el siguiente mensaje para elegir la dimensión:
System.out.print("Porfavor ingrese la dimension de la matriz con la que desea trabajar ");
dimension=dato.nextInt();
int matriz[][]=new int[10][10];
int suma[]=new int[300];
{
{
System.out.print("Digite los elementos de la matriz en la posicion " + i +
j+": " );
matriz[i][j]=dato.nextInt();
}
System.out.print("nn");
}
System.out.println("La matriz es: ");
{
{
System.out.print("t"+matriz[i][j]);
}
System.out.print("n");
}
System.out.println("+++++ Suma de matriz filas +++++");

Matriz Mágica
25
{
suma[i] = 0;
}
4. Suma filas :
//suma filas
{
{
suma[i] = matriz[i][j]+suma[i];
System.out.print("t" + suma[i]);
}
}
System.out.println("+++++ Suma de matriz columnas +++++");
5. Suma columnas:
//suma columnas
{
{
suma[j + dimension] = matriz[i][j]+suma[j + dimension] ;
System.out.print("t "+ suma[j + dimension]);
}
}
System.out.println("+++++ Suma de matriz diagonales +++++");
6. Suma diagonales:
//suma diagonales
{
suma[2 * dimension] = matriz[i][i]+suma[2 * dimension] ;
System.out.print("t "+ suma[2 * dimension]);
}
System.out.println("nn");

Matriz Mágica
26
{
suma[2 * dimension + 1] = matriz[i][(dimension - 1) - i]+suma[2 * dimension + 1]
;
System.out.print("t "+ suma[2 * dimension + 1]);
}
//verificar si la matriz es magica
cont = 0;
cont = suma[0];
for (i = 1; i < 2 * dimension+1 ; i++)
{
if (cont != suma[i])
{
System.out.println("La matriz no es magica");
i=2*dimension+3;
}
else
{
if (cont == suma[i])
{
System.out.println("La matriz es magica y su suma es "+cont);
i=2*dimension+3;
}
}
}
}
}
8. Fin de ciclo
*MATRIZ MÁGICA:
1. Ejecutamos el programa y elegimos la dimensión con la que trabajemos: (En este caso = 4)

Matriz Mágica
27
2. Digitamos los valores de nuestra matriz de inicio a fin :
3. Resultados:
*MATRIZ NO MÁGICA:
4. Resultados:

Matriz Mágica
29
CONCLUSIONES
 En nuestra época la tecnología ocupa un papel muy importante en la sociedad ya que se
ha convertido en una de las herramientas más utilizadas por la sociedad.
 La programación es inevitable en la vida diaria de las personas para cada cosa que
hacemos hay un orden o una sucesión de pasos para llegar a un objetivo.
 Nuestro programa servirá de ayuda al usuario del modo que le permita realizar los
procesos matemáticos de una manera más rápida y con mayor eficiencia.
 El presente algoritmo funcionará exitosamente, si el operador realiza correctamente las
indicaciones dadas.
 Como resultado obtendremos que si la suma de las filas, columnas y diagonales de una
matriz son iguales, ésta se declarará como mágica.
RECOMENDACIONES
 Se deberá usar la tecnología como medio de información para la investigación sin
embargo se recomienda utilizar correctamente
 Es necesario tener claro el concepto de matriz, para poder utilizarlo en cualquier ámbito
de la programación, en este caso como algoritmo.
 Se recomienda buscar la mejor alternativa posible para la solución del problema, ya que
el presente algoritmo no es el único método para desarrollar una matriz mágica.
 El proyecto presentado puede ser modificado de acuerdo a la necesidad del operador.
 Los profesores de los diferentes centros educativos deberían motivar más al uso de la
programación.

Matriz Mágica
30
BIBLIOGRAFÍA
CALDAS, U. D. (s.f.). Matrices. Obtenido de
http://ingenieria1.udistrital.edu.co/udin/pluginfile.php/26700/mod_resource/content/2/Ma
trices.pdf
Matriz mágica. (s.f.). Obtenido de http://dis.unal.edu.co/~programacion/book/modulo3.pdf
Microsoft. (s.f.). Matrices (Guía de programación de C#). Obtenido de
https://msdn.microsoft.com/es-es/library/9b9dty7d.aspx
LIBRO DE PROGRAMACIÓN EN INGLÉS:
Walkenbach, J. (10 de Mayo de 2010). Excel 2010 Power Programming with VBA . Obtenido de
http://www.amazon.com/Excel-2010-Power-Programming-VBA/dp/0470475358

Los sdkn

Más contenido relacionado

La actualidad más candente

Destacado

Similar a Los sdkn

Los sdkn