Universidad Nacional San Cristóbal de Huamanga

Facultad de Ingeniería de Minas Geología y Civil

Escuela Profesional de Ingeniería de Sistemas

TAREA ACADÉMICA n° 02
Arreglos Bidimensionales y Conjuntos

Jordy Julian Huamán Lozano

Código 27115801

Docente

MSc. Ing. Fredy Barrientos

Ayacucho – Perú

Agosto de 2020

3
Contenido:
1 DESARROLLO Y RESULTADOS 5

1.1 Desarrollo 5

1.1.1 Ejercicio A de arreglos multidimensionales 5

1.1.2 Ejercicio D de arreglos multidimensionales: 13

1.2 Resultados e interpretación 16

1.2.1 Ejercicio A de arreglos multidimensionales 16

1.2.2 Ejercicio D de arreglos multidimensionales 17

1.3 Repositorio 18

2 CONCLUSIONES 19
 1 DESARROLLO Y RESULTADOS
1.1 Desarrollo

1.1.1 Ejercicio A de arreglos multidimensionales

Para el siguiente programa se muestran las posibles operaciones con matrices

cuadradas:

● Declaramos las variables y las matrices para ambas matrices:

public class PanPrincipalOperacionMatriz extends

javax.swing.JPanel {

//Definiendo Las globales00

final int MaxDimen = 20;

//Declarar e instanciar las Matrices

int MatrizA[][] = new int[MaxDimen][MaxDimen];
int MatrizB[][] = new int[MaxDimen][MaxDimen];
int contFilaA, contColumA, contFilaB, contColumB;

public PanPrincipalOperacionMatriz() {
initComponents();
//Ingresamos opciones al Combobox de elementos
for (int i = 1; i <= MaxDimen; i++) {
cboDimension.addItem("" + i);

//Ingresamos opciones al Combobox de operaciones

this.cboOperecion.addItem("Suma de elementos de cada
matriz");
this.cboOperecion.addItem("Suma de la diagonal
principal de cada matriz");
this.cboOperecion.addItem("Suma de la diagonal
secundaria de cada matriz");
this.cboOperecion.addItem("Menor elemento de cada
matriz y su posición");
this.cboOperecion.addItem("Mayor elemento de cada
matriz y su posición");
this.cboOperecion.addItem("Sumar matrices A y B");
this.cboOperecion.addItem("Multiplicar matrices A y
B");
}

● Declaramos los métodos para las operaciones con matrices:

private void agregarMatrizA() {
//Declarar las variables locales para la Matriz A
int dimenA, elementoA;

//Leer dimension y elementos de la matriz A

dimenA = cboDimension.getSelectedIndex() + 1;
elementoA = Integer.parseInt(txtElemento.getText());
 //Guardar el elemento leído
MatrizA[contFilaA][contColumA] = elementoA;

//Mostrar el valor ingresado

txtSalida.append("\n A [ " + (contColumA + 1) + " ]
");
txtSalida.append(" [ " + (contFilaA + 1) + " ] ");
txtSalida.append(": " +
MatrizA[contFilaA][contColumA]);

//Incrementamos el contador de filas

contFilaA++;

//Para ingresar varios elementos por fila

if (contFilaA == dimenA) {
contFilaA = 0;
contColumA++;

}
}

private void agregarMatrizB() {

//Declarar las variables locales para la Matriz B
int dimenB, elementoB;

//Leer dimension y elementos de la matriz B

dimenB = cboDimension.getSelectedIndex() + 1;
elementoB = Integer.parseInt(txtElemento.getText());

//Guardar el elemento leído

MatrizB[contFilaB][contColumB] = elementoB;

//Mostrar el valor ingresado

txtSalida.append("\n B [ " + (contColumB + 1) + " ]
");
txtSalida.append(" [ " + (contFilaB + 1) + " ] ");
txtSalida.append(": " +
MatrizB[contFilaB][contColumB]);

//Incrementamos el contador de filas

contFilaB++;

//Para ingresar varios elementos por fila

if (contFilaB == dimenB) {
contFilaB = 0;
contColumB++;
}
}

private void calcular() {

//Declaramos las variables locales
int numElemA, numElemB, numElemSumaMatrices,
numElemProdMat;

//Leer numeros de elementos para A y B

numElemA = cboDimension.getSelectedIndex() + 1;
numElemB = cboDimension.getSelectedIndex() + 1;
numElemSumaMatrices = cboDimension.getSelectedIndex()
+ 1;
numElemProdMat = cboDimension.getSelectedIndex() + 1;
 //Linmpiar tabla
txtSalida.setText("");

//Declaramos un menú para las operaciones

switch (this.cboOperecion.getSelectedIndex()) {
case 1:
mostrarMatrizA(numElemA);
mostrarMatrizB(numElemB);
sumaElemMatA(numElemA);
sumaElemMatB(numElemB);
break;

case 2:
mostrarMatrizA(numElemA);
mostrarMatrizB(numElemB);
sumaDiagPrinMatA(numElemA);
sumaDiagPrinMatB(numElemB);
break;

case 3:
mostrarMatrizA(numElemA);
mostrarMatrizB(numElemB);
sumaDiagSecMatA(numElemA);
sumaDiagSecMatB(numElemB);
break;

case 4:
mostrarMatrizA(numElemA);
mostrarMatrizB(numElemB);
menorElemMatA(numElemA);
menorElemMatB(numElemB);
break;

case 5:
mostrarMatrizA(numElemA);
mostrarMatrizB(numElemB);
mayorElemMatA(numElemA);
mayorElemMatB(numElemB);
break;

case 6:
mostrarMatrizA(numElemA);
mostrarMatrizB(numElemB);
sumaMatrices(MatrizA, MatrizB,
numElemSumaMatrices);
break;

case 7:
mostrarMatrizA(numElemA);
mostrarMatrizB(numElemB);
ProductoMatrices(MatrizA, MatrizB,
numElemProdMat);
break;
}
}

//Método suma de elementos de la matriz A

private void sumaElemMatA(int numElemA) {
txtSalida.append("\n");
int sumaElemMatA = 0;
 for (contFilaA = 0; contFilaA < numElemA;
contFilaA++) {
for (contColumA = 0; contColumA < numElemA;
contColumA++) {
sumaElemMatA +=
MatrizA[contFilaA][contColumA];

}
}
txtSalida.append("La suma de elementos de A es: " +
sumaElemMatA);
}

//Método suma de elementos de la matriz B

private void sumaElemMatB(int numElemB) {
int sumaElemMatB = 0;

txtSalida.append("\n");
for (contFilaB = 0; contFilaB < numElemB;
contFilaB++) {
for (contColumB = 0; contColumB < numElemB;
contColumB++) {
sumaElemMatB +=
MatrizB[contFilaB][contColumB];
}
}
txtSalida.append("La suma de elementos de B es: " +
sumaElemMatB);
}

private void sumaDiagPrinMatA(int numElemA) {

int sumaDiagA = 0;
int diagPrincMatrA[] = new int[numElemA];
txtSalida.append("\n");
for (contFilaA = 0; contFilaA < numElemA;
contFilaA++) {
for (contColumA = 0; contColumA < numElemA;
contColumA++) {
if (contFilaA == contColumA) {
diagPrincMatrA[contFilaA] +=
MatrizA[contFilaA][contColumA];
}
}
}
for (int elemento : diagPrincMatrA) {
sumaDiagA += elemento;
}
txtSalida.append("La suma de la diagonal principal de
A es: "
+ sumaDiagA);
}

private void sumaDiagPrinMatB(int numElemB) {

int sumaDiagB = 0;
int diagPrincMatrB[] = new int[numElemB];
txtSalida.append("\n");
for (contFilaB = 0; contFilaB < numElemB;
contFilaB++) {
for (contColumB = 0; contColumB < numElemB;
contColumB++) {
 if (contFilaB == contColumB) {
diagPrincMatrB[contFilaB] +=
MatrizB[contFilaB][contColumB];
}
}
}
for (int elemento : diagPrincMatrB) {
sumaDiagB += elemento;
}
txtSalida.append("La suma de la diagonal principal de
B es: "
+ sumaDiagB);

private void mostrarMatrizA(int numElemA) {

txtSalida.append("\nElementos de la Matriz A:\n");
for (contFilaA = 0; contFilaA < numElemA;
contFilaA++) {
for (contColumA = 0; contColumA < numElemA;
contColumA++) {
txtSalida.append("\t" +
MatrizA[contFilaA][contColumA]);
}
txtSalida.append("\n");
}

private void mostrarMatrizB(int numElemB) {

txtSalida.append("\nElementos de la Matriz B:\n");
for (contFilaB = 0; contFilaB < numElemB;
contFilaB++) {
for (contColumB = 0; contColumB < numElemB;
contColumB++) {
txtSalida.append("\t" +
MatrizB[contFilaB][contColumB]);
}
txtSalida.append("\n");
}
}

private void sumaDiagSecMatA(int numElemA) {

int sumaDiagSecA = 0;
int diagSecMatrA[] = new int[numElemA];
txtSalida.append("\n");
for (contFilaA = 0; contFilaA < numElemA;
contFilaA++) {
for (contColumA = 0; contColumA < numElemA;
contColumA++) {
if ((contFilaA + contColumA) == numElemA - 1)
{
diagSecMatrA[contFilaA] +=
MatrizA[contFilaA][contColumA];
}
}
}
for (int elemento : diagSecMatrA) {
sumaDiagSecA += elemento;
}
 txtSalida.append("La suma de la diagonal secundaria
de A es: "
+ sumaDiagSecA);
}

private void sumaDiagSecMatB(int numElemB) {

int sumaDiagSecB = 0;
int diagSecMatrB[] = new int[numElemB];
txtSalida.append("\n");
for (contFilaB = 0; contFilaB < numElemB;
contFilaB++) {
for (contColumB = 0; contColumB < numElemB;
contColumB++) {
if ((contFilaB + contColumB) == numElemB - 1)
{
diagSecMatrB[contFilaB] =
MatrizB[contFilaB][contColumB];
}
}
}
for (int elemento : diagSecMatrB) {
sumaDiagSecB += elemento;
}
txtSalida.append("La suma de la diagonal secundaria
de B es: "
+ sumaDiagSecB);
}

private void menorElemMatA(int numElemA) {

int menorA, filaMenorA, columnMenorA;
menorA = MatrizA[0][0];
filaMenorA = columnMenorA = 0;
txtSalida.append("\n");
for (contFilaA = 0; contFilaA < numElemA;
contFilaA++) {
for (contColumA = 0; contColumA < numElemA;
contColumA++) {
if (MatrizA[contFilaA][contColumA] < menorA)
{
menorA = MatrizA[contFilaA][contColumA];
filaMenorA = contFilaA;
columnMenorA = contColumA;
}
}
}
txtSalida.append("El elemento menor de A es: " +
menorA);
txtSalida.append("\nPosicionada en la: \tFila: " +
(filaMenorA + 1)
+ "\tColunma: " + (columnMenorA + 1));
}

private void menorElemMatB(int numElemB) {

int menorB, filaMenorB, columnMenorB;
filaMenorB = columnMenorB = 0;
menorB = MatrizB[0][0];
txtSalida.append("\n");
for (contFilaB = 0; contFilaB < numElemB;
contFilaB++) {
for (contColumB = 0; contColumB < numElemB;
contColumB++) {
 if (MatrizB[contFilaB][contColumB] < menorB)
{
menorB = MatrizB[contFilaB][contColumB];
filaMenorB = contFilaB;
columnMenorB = contColumB;
}
}
}
txtSalida.append("El elemento menor de B es: " +
menorB);
txtSalida.append("\nPosicionada en la: \tFila: " +
(filaMenorB + 1)
+ "\tColunma: " + (columnMenorB + 1));
}

private void mayorElemMatA(int numElemA) {

int mayorA, filaMayorA, columnMayorA;
filaMayorA = columnMayorA = 0;
mayorA = MatrizA[0][0];
txtSalida.append("\n");
for (contFilaA = 0; contFilaA < numElemA;
contFilaA++) {
for (contColumA = 0; contColumA < numElemA;
contColumA++) {
if (MatrizA[contFilaA][contColumA] > mayorA)
{
mayorA = MatrizA[contFilaA][contColumA];
filaMayorA = contFilaA;
columnMayorA = contColumA;
}
}
}
txtSalida.append("El elemento mayor de A es: " +
mayorA);
txtSalida.append("\nPosicionada en la: \tFila: " +
(filaMayorA + 1)
+ "\tColunma: " + (columnMayorA + 1));
}

private void mayorElemMatB(int numElemB) {

int mayorB, filaMayorB, columnMayorB;
filaMayorB = columnMayorB = 0;
mayorB = MatrizB[0][0];
txtSalida.append("\n");
for (contFilaB = 0; contFilaB < numElemB;
contFilaB++) {
for (contColumB = 0; contColumB < numElemB;
contColumB++) {
if (MatrizB[contFilaB][contColumB] > mayorB)
{
mayorB = MatrizB[contFilaB][contColumB];
filaMayorB = contFilaB;
columnMayorB = contColumB;
}
}
}
txtSalida.append("El elemento mayor de B es: " +
mayorB);
txtSalida.append("\nPosicionada en la: \tFila: " +
(filaMayorB + 1)
+ "\tColunma: " + (columnMayorB + 1));
 }

private void sumaMatrices(int[][] MatrizA, int[][]

MatrizB,
int numElemSumaMatrices) {
int sumaMatrices[][] = new
int[numElemSumaMatrices][numElemSumaMatrices];
txtSalida.append("\n");
for (int i = 0; i < numElemSumaMatrices; i++) {
for (int j = 0; j < numElemSumaMatrices; j++) {
sumaMatrices[i][j] = MatrizA[i][j] +
MatrizB[i][j];

}
}
txtSalida.append("La suma de Matrices A + B es: ");
txtSalida.append("\n");
for (int i = 0; i < numElemSumaMatrices; i++) {
txtSalida.append("");
for (int j = 0; j < numElemSumaMatrices; j++) {
txtSalida.append("\t" + sumaMatrices[i][j]);
}
txtSalida.append("\n");
}

private void ProductoMatrices(int[][] MatrizA, int[][]

MatrizB,
int numElemProdMat) {
int producto = 0;
int prodMatrices[][] = new
int[numElemProdMat][numElemProdMat];
txtSalida.append("\n");
for (int i = 0; i < numElemProdMat; i++) {
for (int j = 0; j < numElemProdMat; j++) {
for (int k = 0; k < numElemProdMat; k++) {
prodMatrices[i][j] +=
MatrizA[i][j]*MatrizB[j][k];
}

}
}
txtSalida.append("El producto de ambas matrices AxB
es: ");
txtSalida.append("\n");
for (int i = 0; i < numElemProdMat; i++) {
txtSalida.append("");
for (int j = 0; j < numElemProdMat; j++) {
txtSalida.append("\t" + prodMatrices[i][j]);
}
txtSalida.append("\n");
}
}

}
  Además, este código está implementado en un panel (Ilustración 1.1):

Ilustración 1.1: Panel del ejercicio A.

1.1.2 Ejercicio D de arreglos multidimensionales:

El siguiente programa nos muestra la conversión que se puede hacer a una fecha
ingresada mediante un panel:

 Declaramos las variables y hacemos la lectura de los valores:

private void ingresar() {

int dia, mes, anio;
String cadena;

dia = Integer.parseInt(txtDia.getText());
mes = Integer.parseInt(txtMes.getText());
anio = Integer.parseInt(txtAño.getText());
}

 Y también las condicionales:

if (dia <= 31 && mes <= 12){

if (mes == 1) {
if (anio <= 9) {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de enero del 200"
+ String.valueOf(anio));
} else {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de enero del 20"
+ String.valueOf(anio));
}
 }

if (mes == 2) {
if (anio <= 9) {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de febrero del 200"
+ String.valueOf(anio));
} else {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de febrero del 20"
+ String.valueOf(anio));
}

}
if (mes == 3) {
if (anio <= 9) {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de marzo del 200"
+ String.valueOf(anio));
} else {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de marzo del 20"
+ String.valueOf(anio));
}

}
if (mes == 4) {
if (anio <= 9) {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de abril del 200"
+ String.valueOf(anio));
} else {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de abril del 20"
+ String.valueOf(anio));
}

}
if (mes == 5) {
if (anio <= 9) {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de mayo del 200"
+ String.valueOf(anio));
} else {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de mayo del 20"
+ String.valueOf(anio));
}

}
if (mes == 6) {
if (anio <= 9) {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de junio del 200"
+ String.valueOf(anio));
} else {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de junio del 20"
+ String.valueOf(anio));
}
 }
if (mes == 7) {
if (anio <= 9) {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de julio del 200"
+ String.valueOf(anio));
} else {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de julio del 20"
+ String.valueOf(anio));
}

}
if (mes == 8) {
if (anio <= 9) {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de agosto del 200"
+ String.valueOf(anio));
} else {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de agosto del 20"
+ String.valueOf(anio));
}

}
if (mes == 9) {
if (anio <= 9) {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de setiembre del 200"
+ String.valueOf(anio));
} else {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de setiembre del 20"
+ String.valueOf(anio));
}

}
if (mes == 10) {
if (anio <= 9) {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de octubre del 200"
+ String.valueOf(anio));
} else {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de octubre del 20"
+ String.valueOf(anio));
}

}
if (mes == 11) {
if (anio <= 9) {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de noviembre del 200"
+ String.valueOf(anio));
} else {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de noviembre del 20"
+ String.valueOf(anio));
}

}
 if (mes == 12) {
if (anio <= 9) {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de diciembre del 200"
+ String.valueOf(anio));
} else {
txtSalida.setText("\t" + String.valueOf(dia)
+ " de diciembre del 20"
+ String.valueOf(anio));
}

}
}else{
txtSalida.setText("La fecha ingresada no
existe!!!");
}

 Además, tenemos un panel donde está implementado este código (Ilustración

1.2):

Ilustración 1.2: Panel del ejercicio D

1.2 Resultados e interpretación

1.2.1 Ejercicio A de arreglos multidimensionales

Al ejecutar el ejercicio A se obtiene el siguiente resultado (Ilustración 1.3):

 Ilustración 1.3: GUI ejecutado del ejercicio A

Interpretación: Al momento de ingresar un valor en el cuadro de texto definido por

txtElelmento el programa capta los valores ingresados al programa al pulsar los botones
“Agregar a matriz A” y “Agregar a matriz B” para construir las matrices de cada matriz.
Claro siempre tomando en cuenta el rango para ambas matrices, establecidas antes con
el Combobox de números.

A continuación, se tiene otro Combobox (cboOperacion) en el cual alberga una serie

de operaciones básicas que se pueden realizar con matrices cuadradas.

1.2.2 Ejercicio D de arreglos multidimensionales

En este programa muestra una GUI que permite al usuario cambiar el formato de la
fecha introducida en el cuadro de texto (Ilustración 1.4):
 Ilustración 1.4: GUI del ejercicio D.

Interpretación: Al ingresar los datos de tipo string en los Apartados para el día, el mes
y el año el programa los convierte haciendo un cast y los transforma en enteros para
luego hacer evaluarlos con la condición que los días no tienen que sobrepasar los 31,
ni tampoco los meses los 12, luego hace otra evaluación condicionándolos para cada
valor del mes ingresado: si mes = 1 entonces se devuelve el valor en valor de enero, y
sucesivamente hasta llegar a los 12 meses.

Si sobrepasa estos valores, el programa devuelve un mensaje: “Esta fecha no existe!!”

1.3 Repositorio

Los programas para los ejercicios están en un solo paquete llamado TA02 (Ilustración
1.5):

Ilustración 1.5: Subida exitoso al repositorio del paquete de ejercicios.

 2 CONCLUSIONES
 Crear arreglos multidimensionales fue todo un éxito;
 Para poder guardar y leer los datos de un arreglo es necesario el método
getText() si se está usando un panel para la interface de usuario con un cuadro
de texto como entrada de valores.
 Es posible realizar cálculos con los elementos de un arreglo multidimensional
haciendo una simple llamada a un método. Como por ejemplo para un botón
calcular, se puede hacer la llamada a calcular() donde albergaría una serie de
operaciones convenientes con los elementos ya ingresados anteriormente.