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

Í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..............................................................................................................6ILUSTRACIÓN 2: MATRIZ MONTOS...............................................................................................8ILUSTRACIÓN 3 MATRIZ MÁGICA..................................................................................................8ILUSTRACIÓN 4: ARREGLO DE DATOS..........................................................................................8ILUSTRACIÓN 5: ENTRADAS Y SALIDAS DEL ALGORITMO...........................................................9

2

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.

3

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.

4

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.

5

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.

6

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:

7

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 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:

8

montos : matriz [6][10] de real

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:=0MIENTRAS (k<10) HACER

montos[5][k]:= 5,5k:=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.

9

https://msdn.microsoft.com/es-es/library/2s05feca.aspx

https://msdn.microsoft.com/es-es/library/2yd9wwz4.aspx

https://msdn.microsoft.com/es-es/library/0a7fscd0.aspx

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.

10

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ÓDIGOUna 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 enterosInicio

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

11

escribir(“Por favor digite el dato en la posición”)escribir(i, j)leer(magica[i][j])

fin_para fin_para

Paso 3Paso 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 para(j=0 hasta dimension -1) hacer sumas[i] =magica[i][j] +sumas[i] fin_para fin_para//Sumas correspondientes a las columnas para(j=0 hasta dimension -1) hacer para(i=0 hasta dimension -1) hacer sumas[j+ dimension]=magica[i][j]+sumas[j+ dimension] fin_para fin_para//Sumas correspondientes a las diagonalespara(i=0 hasta dimension -1) hacer sumas[2* dimension]=magica[i][i]+sumas[2* dimension] fin_para para(i=0 hasta dimension -1) hacer 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

12

y se lleva el contador i más allá del final del arreglo, si por el contrario se llega al final del arreglo, 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_sifin-parasi(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 principalvariables i, j, aux, dimension, suma: entero //i señala las filas //j señala las columnascon=0: enteromagica: matriz [10][10] de enterossumas: arreglo [22] de enterosInicioescribir(“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

escribir(“Por favor digite el dato en la posición”)escribir(i,j)leer(magica[i][j])

fin_para fin_parapara(i=0 hasta 2* dimension +2) hacer sumas[i]:=0fin_para

//Sumas correspondientes a las filaspara(i=0 hasta dimension -1) hacer para(j=0 hasta dimension -1) hacer

13

sumas[i]=magica[i][j]+sumas[i] fin_parafin_para

//Sumas correspondientes a las columnaspara(j=0 hasta dimension -1) hacer para(i=0 hasta dimension -1) hacer sumas[j+ dimension]=magica[i][j]+sumas[j+ dimension] fin_parafin_para

//Sumas correspondientes a las diagonalespara(i=0 hasta dimension -1) hacer sumas[2* dimension]=magica[i][i]+sumas[2* dimension]fin_parapara(i=0 hasta dimension -1) hacer sumas[2* dimension +1]=magica[i][( dimension -1)-i]+sumas[2* dimension +1]; fin_paracon=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_sifin-parasi(i=2* dimension +2) escribir(“la matriz es mágica y la suma es:”) escribir(con);fin_sifin-procedimiento

CÓDIGO EN VISUAL BASIC:

1. Definiremos las variables q vamos a necesitar:Dim i As IntegerDim j As IntegerDim aux As IntegerDim dimension As IntegerDim cont As IntegerDim Matriz(10, 10) As IntegerDim suma(300) As Integer

2. Desplegaremos el siguiente mensaje:

dimension = InputBox("Porfavor ingrese la dimension de la matriz con la que desea trabajar ")

14

3. Ciclo para generar la matriz:

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 = 39Cells(3, 2).BorderAround (xlContinuous)Cells(3, 2).BorderAround (xlHairline)For i = 0 To dimension - 1 For j = 0 To dimension - 1 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 jNext i

5. Suma filas:

For i = 0 To 2 * dimension + 2 suma(i) = 0Next i

'Suma FilasWorksheets("Hoja1").Cells(9, 1).Value = ("La suma de sus filas es: ")Cells(9, 1).Interior.ColorIndex = 43Cells(9, 1).BorderAround (xlContinuous)Cells(9, 1).BorderAround (xlHairline)For i = 0 To dimension - 1 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) For j = 0 To dimension - 1 suma(i) = suma(i) + Matriz(i, j) Worksheets("Hoja1").Cells(10 + i, 2 + j).Value = (suma(i)) Cells(10 + i, 2 + j).Interior.ColorIndex = 45 Cells(10 + i, 2 + j).BorderAround (xlContinuous) Cells(10 + i, 2 + j).BorderAround (xlHairline)

15

Next jNext i

6. Suma columnas:

'Suma ColumnasWorksheets("Hoja1").Cells(15, 1).Value = ("La suma de sus columnas es: ")Cells(15, 1).Interior.ColorIndex = 10Cells(15, 1).BorderAround (xlContinuous)Cells(15, 1).BorderAround (xlHairline)For j = 0 To dimension - 1 For i = 0 To dimension - 1 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)) Cells(17 + i, 1 + j).Interior.ColorIndex = 45 Cells(17 + i, 1 + j).BorderAround (xlContinuous) Cells(17 + i, 1 + j).BorderAround (xlHairline) Next iNext j

7. Suma diagonales:'Suma Diagonalesj = 0Worksheets("Hoja1").Cells(21, 1).Value = ("La suma de sus diagonales es: ")Cells(21, 1).Interior.ColorIndex = 23Cells(21, 1).BorderAround (xlContinuous)Cells(21, 1).BorderAround (xlHairline)For i = 0 To dimension - 1 Worksheets("Hoja1").Cells(22, 1).Value = ("Suma diagonal izq-der ") Cells(22, 1).Interior.ColorIndex = 46 Cells(22, 1).BorderAround (xlContinuous) Cells(22, 1).BorderAround (xlHairline) suma(2 * dimension) = suma(2 * dimension) + Matriz(i, i) Worksheets("Hoja1").Cells(22 + i, 2 + j).Value = (suma(2 * dimension)) Cells(22 + i, 2 + j).Interior.ColorIndex = 44 Cells(22 + i, 2 + j).BorderAround (xlContinuous) Cells(22 + i, 2 + j).BorderAround (xlHairline) j = j + 1Next iWorksheets("Hoja1").Cells(22, j + 2).Value = ("Suma diagonal der-izq ")Cells(22, j + 2).Interior.ColorIndex = 22Cells(22, j + 2).BorderAround (xlContinuous)

16

Cells(22, j + 2).BorderAround (xlHairline)For i = 0 To dimension - 1 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)) Cells(22 + i, 3 + j).Interior.ColorIndex = 44 Cells(22 + i, 3 + j).BorderAround (xlContinuous) Cells(22 + i, 3 + j).BorderAround (xlHairline) j = j + 1Next i

8. Verificación de la matriz:

'Verificar si la matriz es magicacont = 0cont = 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) Cells(27, 1).Interior.ColorIndex = 3 Else If (cont <> suma(i)) Then Worksheets("Hoja1").Cells(27, 1).Value = ("La matriz no es magica") Cells(27, 1).Interior.ColorIndex = 3 End If End IfNext 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)

17

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:

18

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 necesarioscanf_s("%d", &dimension);


for (i = 0; i < dimension; i++){

for (j = 0; j < dimension; j++)

19

{printf("Digite los elementos de la matriz en la posicion %d %d ", i, j);

scanf_s("%d", &matriz[i][j]);

}

printf("\n\n");}for (i = 0; i < dimension; i++){

for (j = 0; j < dimension; j++){

printf("\t%d", matriz[i][j]);}printf("\n\n");

}printf("\n");printf("+++++ Suma de matriz filas +++++");printf("\n");for (i = 0; i < 2 * dimension + 2; i++){

suma[i] = 0;}

4. Suma filas://suma filasfor (i = 0; i < dimension; i++){


suma[i] = suma[i] + matriz[i][j];printf("\t %d", suma[i]);

}printf("\n\n");

}printf("\n");printf("+++++ Suma de matriz columnas +++++");printf("\n");

5. Suma columnas:

//suma columnasfor (j = 0; j < dimension; j++){


suma[j + dimension] = suma[j + dimension] + matriz[i][j];

20

printf("\t %d", suma[j + dimension]);}printf("\n\n");

}printf("\n");printf("+++++ Suma de matriz diagonales +++++");printf("\n");

6. Suma diagonales:

//suma diagonalesfor (i = 0; i < dimension; i++){

suma[2 * dimension] = suma[2 * dimension] + matriz[i][i];printf("\t %d", suma[2 * dimension]);

}printf("\n\n");printf("\n");for (i = 0; i < dimension; i++){

suma[2 * dimension + 1] = suma[2 * dimension + 1] + matriz[i][(dimension - 1) - i];printf("\t %d", suma[2 * dimension + 1]);

}printf("\n\n");


//verificar si la matriz es magicacont = 0;cont = suma[0];for (i = 1; i < 2 * dimension + 1; i++){

if ((cont != suma[i])){

printf("La matriz no es magica");i = 2 * dimension + 3;

}

elseif (i = 2 * dimension + 2){

printf("La matriz es magica y su suma es %d", cont);}

}8. Fin del algoritmo:

21

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:

22

*MATRIZ NO MÁGICA:Los pasos 1,2 y 3 serán exactamente iguales, lo que cambiará son los resultados obtenidos:


4. Resultados:

23

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("\n\n");

} System.out.println("La matriz es: ");



System.out.print("\t"+matriz[i][j]);}System.out.print("\n");

}System.out.print("\n");System.out.println("+++++ Suma de matriz filas +++++");

24

for (i = 0; i < 2 * dimension + 2; i++){

suma[i] = 0;}

4. Suma filas :

//suma filasfor (i = 0; i < dimension; i++){


suma[i] = matriz[i][j]+suma[i];System.out.print("\t" + suma[i]);

}System.out.print("\n\n");

}System.out.print("\n");System.out.println("+++++ Suma de matriz columnas +++++");

5. Suma columnas:

//suma columnasfor (j = 0; j < dimension; j++){


suma[j + dimension] = matriz[i][j]+suma[j + dimension] ;System.out.print("\t "+ suma[j + dimension]);

}System.out.print("\n\n");

}System.out.print("\n");System.out.println("+++++ Suma de matriz diagonales +++++");

6. Suma diagonales:

//suma diagonalesfor (i = 0; i < dimension; i++){

suma[2 * dimension] = matriz[i][i]+suma[2 * dimension] ;System.out.print("\t "+ suma[2 * dimension]);

}System.out.println("\n\n");for (i = 0; i < dimension; i++){

25

suma[2 * dimension + 1] = matriz[i][(dimension - 1) - i]+suma[2 * dimension + 1] ;

System.out.print("\t "+ suma[2 * dimension + 1]);}System.out.print("\n\n");


//verificar si la matriz es magicacont = 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)

26

2. Digitamos los valores de nuestra matriz de inicio a fin :

3. Resultados:

*MATRIZ NO MÁGICA:

Los pasos 1,2 y 3 serán exactamente iguales, lo que cambiará son los resultados obtenidos:


4. Resultados:

27

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.

29

BIBLIOGRAFÍA

CALDAS, U. D. (s.f.). Matrices. Obtenido de http://ingenieria1.udistrital.edu.co/udin/pluginfile.php/26700/mod_resource/content/2/Matrices.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

30

los sdkn

Documents