Java - Ejercicio de arreglos en java

 
Vista:
sin imagen de perfil
Val: 9
Ha aumentado 1 puesto en Java (en relación al último mes)
Gráfica de Java

Ejercicio de arreglos en java

Publicado por Alexander (5 intervenciones) el 10/11/2018 21:07:26
Suponga que se tiene una clase Matriz la cual contiene como atributo un arreglo de 2 dimensiones de enteros. Elabore un método que reciba como parámetro dos objetos tipo Matriz (A y B) y genere un vector que contenga los números que se encuentran en la matriz A y NO se encuentran en la matriz B.

¿Como realizarían este ejercicio en código JAVA?
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Ejercicio de arreglos en java

Publicado por Kabuto (1378 intervenciones) el 11/11/2018 21:52:30
Te cuento como lo he enfocado yo.

He creado una clase llamada Matriz.

Con un atributo, que es un matriz (un array de dos dimensiones) de enteros

En su constructor he hecho que reciba dos valores enteros para establececer las dimensiones del atributo matriz.
Además, el contructor rellena la matriz con números al azar entre 0 y 99. Así me ahorro el tener que proporcionale valores manualmente.

Luego, la he dotado de tres métodos.

EL primer y más importante, es un método que recibe por argumentos otro objeto Matriz, que sería el que considerariamos la matriz B.
Este método lo que hace es recorrer la matriz A, usando dos bucles anidados por supuesto, y por cada elemento, comprueba si existe en la matriz B, la cuál hay que recorrer con sus propios dos bucles anidados.
Esto implicaría 4 bucles anidados, lo cual quizás hace que el código sea algo feo.

Por ello, he creado el segundo método, que lo que hace es recibir un valor entero y dice true o false si está contenido en el objeto Matriz en cuestión.

Así el primer método se apoya en este segundo método para comprobar si hay elementos en matriz A, no existentes en matriz B.

Estos elementos no existentes, son los que hay que meter en un array y esto será lo que retorne este método.

Luego está el tercer método, que lo único que hace es mostrar los valores de matriz en la pantalla.

Bien, luego creo un método main() para poner en marcha el ejercicio y comprobar el funcionamiento.
Aquí lo que hago es crear dos objetos de nuestra clase Matriz: matrizA y matrizB.

Luego muestro el contenido de cada uno de ellas por pantalla.

Después llamo al método que me devuelve el array de elementos no repetidos.

Y una vez lo tengo lo muestro en pantalla.


Estos son los pasos que he seguido, y puedes intentar realizarlos tú.
Para cuando te atasques o lo que sea, te pongo aquí mi código y también el resultado que obtengo en pantalla.

Hago notar que NO lo he hecho EXACTAMENTE a como lo pide el enunciado, ya que este pide un método ajeno que recibar los dos objetos Matriz y proporcione el array de no repetidos.
He preferido enfocarlo de otro modo y te puede servir para intentar tú hacerlo tal y como pide el enunciado.

Cualquier duda, pregunta por aquí. Un saludo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
public class Matriz {
	//Atributos
	int[][] matriz;
 
	//Constructor
	public Matriz(int dim1, int dim2) {
		matriz = new int[dim1][dim2];
		//Hacemos que la matriz se autorellene con numeros al azar
		for (int i = 0; i < dim1; i++)
			for (int j = 0; j < dim2; j++)
				matriz[i][j] = (int)(Math.random()*100);
	}
 
	//Metodos
	/**
	 * Este método recibe otro objeto de la clase Matriz y construye un vector
	 * con los valores que existen en esta Matriz, pero que no existen en la Matriz
	 * recibida como parametro. 
	 * @param matrizB Objeto Matriz con el que compararemos valores.
	 * @return vector de enteros con los valores existente en esta matriz, 
	 * y no existentes en la segunda matriz.
	 */
	public int[] getValoresNoRepetidos(Matriz matrizB) {
		/*
		 * La mecánica será recorrer esta matriz.
		 * Por cada valor, comprobaremos si existe en la otra matriz, que llamaremos matrizB.
		 * Para agilizar esta comprobación, nos apoyaremos en el método contieneValor()
		 * que se encargará de recorrer la matrizB cada vez que le pasemos un valor de esta matriz.
		 * 
		 * Si el valor no existe en la matrizB, entonces este valor irá al vector que estamos construyendo.
		 * Aquí se nos presenta un problema: NO sabemos de antemano cuanto ha de medir el vector que estamos construyendo,
		 * porque no sabemos cuantos valores vamos a encontrar válidos para introducir en el vector.
		 * Podrían ser 5 valores, podrian ser 50, 10... o podría ser ninguno...
		 * 
		 * Para esquivar este problema, podemos solucionarlo haciendo dos recorridos a las matrices A y B.
		 * El primer recorrido contaremos cuantos valores son válidos para introducir en el vector.
		 * Tras haber contado, ya podemos establecer el tamaño al vector.
		 * El segundo recorrido, introduciremos los valores en el vector.
		 */
		int contador = 0;
		//Primer recorrido. Contar valores no existentes en matrizB para decidir el tamaño del vector.
		for (int i = 0; i < matriz.length; i++)
			for (int j = 0; j < matriz[0].length; j++)
				if (!matrizB.contieneValor(matriz[i][j]))//Si matrizB NO contiene el valor de nuestra matriz...
					contador++; //Aumentamos contador
 
		//YA hemos contado. Ya sabemos que tamaño ha de tener el vector
		int[] valores = new int[contador];
 
		//Segundo recorrido.Los valores antes contados, ahora los introducimos en el vector.
		//Necesitaremos un tercer indice para señalar las posiciones del vector donde hay que introducir los valores
		int z = 0;
		for (int i = 0; i < matriz.length; i++)
			for (int j = 0; j < matriz[0].length; j++)
				if (!matrizB.contieneValor(matriz[i][j]))
				{
					valores[z] = matriz[i][j];//Guardamos valor en el vector.
					z++;//El indice del vector apunta al siguiente elemento para el próximo valor que haya que guardar
				}
 
		//Listo, podemos retornar el vector con los valores que existen en esta matriz, pero no existen en la matrizB
		return valores;
	}
 
	/**
	 * Este método recibe un valor entero y comprueba si existe en la matriz.
	 * @param valor entero que queremos saber si está contenido.
	 * @return true si el valor existe en la matriz, false en caso contrario.
	 */
	public boolean contieneValor(int valor) {
		for (int i = 0; i < matriz.length; i++)
			for (int j = 0; j < matriz[0].length; j++)
				if (matriz[i][j] == valor)
					return true;
		//Si tras recorrer la matriz no se ha retornado true, es que el valor no existe en la matriz
		return false;
	}
 
	/**
	 * Este metodo muestra los valores de la matriz en pantalla.
	 */
	public void mostrarMatriz() {
		for (int i = 0; i < matriz.length; i++)
		{
			for (int j = 0; j < matriz[0].length; j++)
				System.out.printf("%2d ", matriz[i][j]);//Formateamos para que todos lo valores ocupen dos cifras en pantalla
			System.out.println(); //Salto de linea
		}
	}
 
	public static void main(String[] args) {
 
		/*
		 * Creamos dos objetos de nuestra clase Matriz.
		 * Cada uno tendrá distintas dimensiones y se 
		 * autorellenan ellos solos con números al azar
		 */
		Matriz matrizA = new Matriz(15, 35);
		Matriz matrizB = new Matriz(10, 20);
 
		//Mostramos matrices en pantalla.
		System.out.println("Valores de la matriz A\n");
		matrizA.mostrarMatriz();
		System.out.println("\nValores de la matriz B\n");
		matrizB.mostrarMatriz();
 
		//Usamos el metodo de nuestra clase Matriz para que nos genere un vector con los valores no repetidos
		int[] noRepetidos = matrizA.getValoresNoRepetidos(matrizB);
 
		//Mostramos los valores obtenidos en el vector
		System.out.println("\n\nValores de Matriz A no existentes en Matriz B");
		for (int num: noRepetidos)
			System.out.print(num + " ");
 
	}
 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
Valores de la matriz A
 
17 66 91 63 20 94 26 48 31 75 14  8 93 26 88 15 59 33 87 91 53 24 85 45 76 90 84 50 61  3 92 93 26 85 99
 6 11 68 55 42 15 98 27 26 17 30 60 77 68 75 65 79 59 70  7 35 37 46 88 26 97  2 41 89 16 97  6 82 16 99
77 24  7 67 97 57 68 53 21  4 29 58 84 55 95  3 48 48 78 11 93 88 85 59 26 65 71 68  8 45 78 82 75  3 44
16 18  2 10 13 95 23 67  8 18 83 93 62 21  3 13 79 11  0 48 97 75 30 93 18 14 30 34 91 31 33 31 69 76  9
62 20  0 65 53 54 63 55 70 25 19 44 14 50 54 44 98 67 89  7 77 72 59 97  2 51 95 34 32 34 66 73 82  1 19
43  8 83 57 46 19 91  0 78 11 47 64 36 42 86 32 27 18 28 52  9 84 41 86 43 77 32 46 67 84 56  4 62  9 27
44  2 33 95 99 42 17 55 82 69  7  7 52 50 38 52 41 21  1 10 10 90 95 52  9 95 70 38  6 49 36 67 50 46 51
43 54 86 71 82 30 78 91 10 14  8 42 99  6 10 47 35  7  0 80 21 84 69  2 59 22  8 38 69 90 15 19 72 73 88
15 53 24 28 38 20 70 73 96 58 81 14 74 85 20 13 70 12 59 14 82 16 78  1 23 38  0 22 95 35 12 90 88 20 11
35 40 48 46 52 28 25 90 11 97 28 96 39 64 68 32 95 72 52 31 59 75  7 88 32 63 17 87 62 54  3 32  1 61 60
56  3 64 94 24 12 30 46  4 30 50 53 81 68 29 28 89  7 97 38 20 81 76 66  6 90 44 54  7 83 91 67 47 86 76
79 24 83 38 93 81 82 70 28 70 64 67 35 76 26 76 59 24  5 32 54 28 85 32 47 46 83 18 44 59 22 62 62  9 94
20 60  2 59  6 56 68 86 49 19 97 30 74 23 16  0 62 69 46 26 33 89 89 65 33 74 16 94 53 62 11 91 21 80 82
44 85 27 99 42  1 39 49 75 45 87 62  8 55 17 99 19 23 64 65 94 53 10 44 63 39 26 49 88 59 46 91 13 21  9
21 95 43 45 45 90 79 23 57 25 97 68  0 86 90 93 82  0 72 74  5 15 23 58 17 98 83 63  2 35 69 22 17 42 62
 
Valores de la matriz B
 
80 65 30 64 48 26 38 47  7  0 74  6 25 34 75 39 69 68 23  2
57  8 70 58 23 63 99 15 48 28 21 93 17 39 64 81 86 61 80 27
27 69  0 22 51 42 80 55 21 97 49 70 89 49 68 67 99 93 63 83
48 95 32 38  8 41 74 19 49 72 20 41 40  5  7 95 43 15 95  5
53 62 58 48 87 79 67 51 71  4 26 73 19 40 95 99 64 25 93 17
41 69 67 26  8 68 54 31 19 34 77  1 69 86 61 33 65 32 70 56
76 44 36 19 72 59 29 46 64 73 57 30 99 69  9 14  7 40 29 64
29 68 55 67 76  4 88 85 67 62 64 24 77 72  5 75 29 52 53  2
79 71 86 20 43 24 68 30 17  5 85 47 75  8 45 29 26 56 80 26
38 86 81 96 68 51 68 25 52 67 13 59 33 16 94 76 64 78 91 13
 
 
Valores de Matriz A no existentes en Matriz B
66 90 84 50 3 92 11 98 60 35 37 82 84 3 11 82 3 18 10 18 3 11 18 50 98 66 82 11 18 84 84 82 50 10 10 90 50 82 10 10 35 84 90 12 82 35 12 90 11 35 90 11 3 60 3 12 50 66 90 82 35 18 60 11 82 10 90 90 82 98 35
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar