Java - Necesito AYUDA en un ejercicio de MATRICES en JAVA!!!!

 
Vista:
sin imagen de perfil

Necesito AYUDA en un ejercicio de MATRICES en JAVA!!!!

Publicado por anonymous (11 intervenciones) el 09/05/2022 21:58:37
Buenas, estoy hace bastante tiempo ya intentando resolver un ejercicio de matrices en Java. El método recibe una matriz, y debe retornar el numero en forma de String si todos los números menores de cada fila son iguales, si no debe retornar "NO HAY".

Este es mi código, no sé que está mal:

public static String menorComunFilas(int[][] matriz) { // metodo principal


String texto="";

boolean ok = true;


for(int i=0; i < matriz.length-1 && ok; i++) {

if(menorComunFila(matriz, i) != menorComunFila(matriz, i+1)) {
ok=false;
}
}



if(!ok) {
texto="NO HAY";

}

if(ok) {
texto=String.valueOf(menorComunFila(matriz, 0));
}
return texto;
}


public static int menorComunFila(int [][] matriz, int fila) { //metodo para hallar el menor numero en cada fila

int menorValor =Integer.MAX_VALUE;

for(int j=0; j<matriz[0].length; j++) {

if (matriz[fila][j] <= menorValor) {
menorValor = matriz[fila][j];

}


}

return menorValor;

}

Desde ya, muchas gracias!!!
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
sin imagen de perfil

Necesito AYUDA en un ejercicio de MATRICES en JAVA!!!!

Publicado por anonymous (11 intervenciones) el 10/05/2022 00:48:14
fue un error mío de comprensión de letra, el ejercicio pide "el menor elemento comun a todas las filas de la matriz. si no hay retorna "NO HAY". por lo tanto, mi codigo esta mal, me quede en blanco de como seria.
1 5 8 4 2
5 2 0 7 9
-3 8 5 -2 2
por ejemplo aqui seria 2 el menor comun. yo pensaba que habia que comparar los menores de todas las filas y ver si coincidian, pero es mas complicado de lo que pensé.
si alguien me ayuda lo agradeceria muchp
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
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

Necesito AYUDA en un ejercicio de MATRICES en JAVA!!!!

Publicado por Kabuto (1381 intervenciones) el 10/05/2022 18:53:45
Pues no es sencillo la verdad.
No es que sea extremadamente difícil, pero sí algo complejo. De hecho, me parece que es demasiado como para resolverlo con un único método, porque requiere de varios bucles anidados haciendo distintas cosas y esto puede dar como resultado un código demasiado caótico.


Así que yo propongo un resultado, pero usando dos métodos de apoyo que se encargan de tareas menores, para no hacerlo todo en uno solo y que no lo entienda ni Dios...

Vamos por partes.
Hay que buscar valores comunes en todas las filas de la matriz y mostrar el menor de ellos.
Lo que podemos hacer es buscar todos los comunes y crear un nuevo array con ellos. Luego, buscaremos el menor dentro de este array.
Así que este array de comunes, tendrá que ir creciendo según vamos encontrando comunes. Esto sería muy fácil si pudiéramos usar colecciones dinámicas como ArrayList, pero intuyo que no es permitido en este ejercicio, así que habrá que hacer trabajo extra para conseguir que el array primitivo (quien tiene un tamaño fijo) vaya creciendo.

Para encontrar comunes, no hace falta recorrer TODA la matriz, elemento a elemento. Basta con recorrer solo las columnas de la primera fila.
Seleccionaremos el número de cada una de estas columnas, y con otro bucle iremos seleccionado el resto de filas al completo
Aquí es donde podemos usar un método "de apoyo", uno que reciba el número que estamos comprobando y una fila completa para devolver true/false según si ese número existe en la fila o no.
Este podría ser ese método:
1
2
3
4
5
6
7
private static boolean existeEnFila(int num, int[] fila) {
		for (int i = 0; i < fila.length; i++)
			if (fila[i] == num)
				return true;
		//Si bucle termina sin devolver true, es que el número no está en la fila
		return false;
	}

Así, si este método nos retorna TRUE para todas las filas, significa que hemos encontrado un número común y lo agregaremos a la lista, es decir, al array que hay que ir haciendo crecer con cada común encontrado.

Tras recorrer todos los elementos(columnas) de la primera fila, ya tendremos la lista de comunes.
Pues ahora, en esa lista, hay que buscar el menor. Esto también se lo podemos encargar a un segundo método "de apoyo":
1
2
3
4
5
6
7
8
9
10
11
12
13
private static int menorComun(int[] comunes) {
 
		if (comunes.length == 1) //Solo hay UN común, no hace falta buscar el menor
			return comunes[0];
		else { //Hay más de un común, buscamos el menor de ellos
			int menor = comunes[0];
			for (int i = 1; i < comunes.length; i++)
				if (comunes[i] < menor)
					menor = comunes[i];
 
			return menor;
		}
	}

Estos dos métodos, serán invocados dentro del método principal, el que se encarga de recibir una matriz y retornar un String con el menor común.
Ese método, hace todo lo que acabo de describir y este sería su código.
Tiene bastantes líneas, pero se debe sobre todo a que he puesto muchos comentarios comentándolo paso a paso.
Si se eliminan los comentarios, y gracias a que los métodos de apoyo ya cargan con parte del código, pues en realidad no es tan largo.
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
private static String menorComunFilas(int[][] matriz) {
		int[] comunes = new int[0]; //Comenzamos con un array de comunes sin longitud
		/*
		 * Para buscar comunes, solo hemos de comprobar los elementos en las columnas
		 * de la primera fila y ver si existen en las siguientes.
		 */
 
		for (int c = 0; c < matriz[0].length; c++) {//Indices de las columnas de la primera fila
			int comprobando = matriz[0][c]; //Seleccionamos número a comprobar
			//Ahora con un segundo bucle, vamos seleccionar el resto de filas
			//y comprobamos si el número actual existe en todas
			boolean esComun = true;
			for (int f = 1; f < matriz.length; f++) {
				if (!existeEnFila(comprobando, matriz[f]))//Si número no existe en esta fila..
					esComun = false;//...pues no es un común
			}
			//Si tras comprobar las filas se confirma que es comun, hay que añadirlo al array de comunes
			if (esComun) { //Confirmado, es un valor común.
				if (comunes.length == 0) {//Si la lista de comunes esta vacía...
					comunes = new int[1]; //..es el momento de iniciarla.
					comunes[0] = comprobando;
				}
				else { //La lista de comunes ya esta iniciada
					/*
					 * Si ya está iniciada, hay que hacer dos cosas:
					 * 1º Comprobar si este número ya existe en la lista de comunes,
					 * pues no es necesario incluirlo más de una vez
					 *
					 * 2º Si no está en la lista, hay que incluirlo. Pero para poder
					 * hacerlo tenemos que hacer crecer el array aumentando su longitud
					 */
					if (!existeEnFila(comprobando, comunes)) { //NO existe en lista, lo incluímos
						int[] temp = comunes; //Hacemos copia de lista actual
						comunes = new int[temp.length + 1]; //Incrementamos longitud de la lista
						//Ahora hay que volver a introducir TODOS los valores en la nueva lista
						for (int i = 0; i < temp.length; i++)
							comunes[i] = temp[i];
						//Solo falta el último común encontrado, que va al final de la lista
						comunes[comunes.length - 1] = comprobando;
					}
				}
			}
			//A partir de aquí, se repite el bucle hasta terminar de recorrer todas las columnas
			//de la primera fila.
		}
 
		/*
		 * Bien, ya hemos comprobado todas la columnas de la primera fila.
		 * Ahora comprobamos si se han encontrado comunes.
		 * Y si se han encontrado, buscaremos el menor de la lista de comunes
		 * que hemos confeccionado.
		 */
		if (comunes.length == 0)
			return"No hay";
		else
			return Integer.toString(menorComun(comunes));
	}

Pues ese sería el método que hace el "trabajo duro".
Lo podemos invocar desde este método main(), donde declaro una matriz, la muestro en pantalla y luego muestro el String que nos devolvería el método anterior:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void main(String[] args) {
		int[][] matriz = {{1,5,8,4,2},
						  {5,2,0,7,9},
						  {-3,8,5,-2,2}};
 
		//Mostramos en pantalla la matriz
		System.out.println("Matriz:");
		for (int i = 0; i < matriz.length; i++)
			System.out.println(Arrays.toString(matriz[i]));
 
		System.out.println("\n--------------\n");
 
		System.out.println(menorComunFilas(matriz));
 
	}

Si lo ejecutamos, vemos en pantalla que parece funcionar correctamente, aunque no lo he probado con distintas matrices.
1
2
3
4
5
6
7
8
Matriz:
[1, 5, 8, 4, 2]
[5, 2, 0, 7, 9]
[-3, 8, 5, -2, 2]
 
--------------
 
2

Haz tú más pruebas con él y nos cuentas como va.

Y pregunta todo lo que necesites si algo no ha quedado claro. Como digo es un ejercicio de cierta complejidad aunque no tan difícil como se antoja al principio.

Un saludo.
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