Java - Ayuda ejercicio basico java

 
Vista:
sin imagen de perfil
Val: 6
Ha aumentado su posición en 3 puestos en Java (en relación al último mes)
Gráfica de Java

Ayuda ejercicio basico java

Publicado por Esther (3 intervenciones) el 21/05/2021 00:51:39
Necesito introducir en un segundo array los números repetidos que encuentre del primer array. Es decir algo similar a ésto:

[1, 2, 4, 4, 3, 3, 1, 5, 3, 5] ==> [4, 3, 1, 5]

Si primero encuentra el 4 repetido coloca primero el 4, y así sucesivamente
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

Ayuda ejercicio basico java

Publicado por Kabuto (979 intervenciones) el 21/05/2021 12:04:25
1
2
3
[1, 2, 4, 4, 3, 3, 1, 5, 3, 5] ==> [4, 3, 1, 5]
 
Si primero encuentra el 4 repetido coloca primero el 4, y así sucesivamente

Bueno, el primer valor repetido es el 1 je je.


A parte de esto.
Lo ideal sería usar algún tipo de colección dinámica, como ArrayList o la clase Vector.

Los arrays primitivos, como el propuesto de ejemplo, tienen el inconveniente de que su tamaño es fijo. Al crearlos, hay que darles un tamaño, que luego no va a poder ser cambiado.

Entonces, para guardar los números repetidos, no podemos usar directamente otro array primitivo. Porque como no sabemos cuántos repetidos vamos a encontrar, no podemos saber que tamaño ha de tener ese array primitivo.

Las colecciones dinámicas en cambio, no tienen un tamaño fijo. Se pueden ir metiendo o quitando valores según necesitamos y de ese modo van creciendo o decreciendo.

Son ideales, pero supongo que van a querer que resuelvas este ejercicio sin usar estas colecciones, que seguramente aún no te las han explicado.

Así que hay que buscar otra alternativa, que nos permita igualmente coleccionar valores repetidos sin necesidad de saber de antemano cuántos valores vamos a encontrar.

Podemos apoyarnos en un objeto String incializado como cadena vacía. Cada valor que detectemos repetido, lo concatenamos como si fuera un carácter de texto en ese String.
Antes de concatenarlo, podemos comprobar si ya existe ese valor en el String, así evitamos repetir los valores que guardamos.

Cuando hayamos comprobado todos los valores, a partir de ese String ahora ya si podemos construir un array primitivo, porque ese String ya nos dice qué tamaño va a necesitar ese array.

Como los números son int, y la cadena donde guardamos es String, habrá que convertir de int a String para guardar valores repetidos. Y luego de String a int para crear el array primitivo del resultado final.

Para recorrer los valores y comprobar si están repetidos, podemos usas dos bucles anidados.

El primer bucle irá seleccionado cada valor del array. El segundo bucle, recorrerá los demás valores y los irá comparando con el seleccionado por el primero.
Si detectamos un valor repetido, y este no existe todavía en el String de apoyo, pues entonces lo concatenaremos.


No se si la explicación me ha quedado clara. Quizás viendo el código, se entiende mejor:

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
public class Repetidos {
 
	public static void main(String[] args) {
 
		int[] numeros = {1, 2, 4, 4, 3, 3, 1, 5, 3, 5};
		String repetidos = ""; //Aquí guardaremos temporalmente los valores repetidos
 
		//Con bucles anidados, seleccionamos valores uno a uno, y comparamos con el resto del array
		for (int i = 0; i < numeros.length; i++) {
			//El bucle anidado comienza en el valor siguiente al seleccionado en el primer bucle
			for (int j = (i + 1); j < numeros.length; j++) {
				//Comparamos valor
				if (numeros[i] == numeros[j]) { //Repetido
					//Al ser un valor int, requiere ser convertido a String para poder trabajar con el
					String valor = Integer.toString(numeros[i]);
					//Guardamos, pero solo si NO existe ya en el String
					if (!repetidos.contains(valor))
						repetidos = repetidos + valor;
				}
			}
		}
 
		//Bucles anidados han terminado, tenemos los valores repetidos en un String
		//Hay que construir un nuevo vector de int a partir de ese String
		int[] valores = new int[repetidos.length()];
		for (int i = 0; i < valores.length; i++)
			valores[i] = Integer.parseInt(repetidos.substring(i, i+1));
 
		//Listo, mostramos los resultados.
 
		System.out.println("Array inicial de numeros:");
		System.out.println(Arrays.toString(numeros));
 
		System.out.println("\nValores repetidos encontrados:");
		System.out.println(Arrays.toString(valores));
 
	}
 
}

Si probamos ese código, en pantalla vemos que da resultados correctos:
1
2
3
4
5
Array inicial de numeros:
[1, 2, 4, 4, 3, 3, 1, 5, 3, 5]
 
Valores repetidos encontrados:
[1, 4, 3, 5]

Si algo no se ha entendido, dímelo y lo aclaramos.
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
sin imagen de perfil
Val: 6
Ha aumentado su posición en 3 puestos en Java (en relación al último mes)
Gráfica de Java

Ayuda ejercicio basico java

Publicado por Esther (3 intervenciones) el 21/05/2021 13:57:52
Hola, tendría que mostrar primero el 4, luego el 3, después el 1 y finalmente el 5.
Es decir, empieza a leer el array principal y lee el 1, después lee el 2, como el 2 no está repetido pasa al 4, a continuación hay otro 4 por lo tanto es el que tiene que tomar primero.
En el array de repetidos tendría que estar 4, 3, 1, 5
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

Ayuda ejercicio basico java

Publicado por Kabuto (979 intervenciones) el 22/05/2021 00:23:42
Mmmh, de acuerdo, pues entonces habrá que cambiar la estrategia.

Podemos usar en este caso dos String.
Uno para anotar los valores que vamos leyendo y el otro para anotar los repetidos, igual que antes.

Antes de anotar un valor en el String de leidos, comprobaremos si ya está anotado.
Si YA está anotado, es que es un repetido, en cuyo caso lo anotaremos en el String de repetidos, a no ser que también esté ahí anotado. Entonces simplemente no habrá que hacer nada.

Luego al final se construye un vector a partir del String de repetidos, como en el ejemplo anterior.

Usando la estrategia de los dos String, la verdad es que se simplifica el código. Ni siquiera vamos a necesitar bucles anidados, bastará con uno solo.
Marco en negrita las líneas de código que cambian respecto al ejemplo anterior:

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
public class Repetidos {
 
	public static void main(String[] args) {
 
		int[] numeros = {1, 2, 4, 4, 3, 3, 1, 5, 3, 5};
		String repetidos = ""; //Aquí guardaremos temporalmente los valores repetidos
		String leidos = ""; //Sirve para "recordar" los valores leídos, y detectar posteriores repeticiones
 
		//Con un bucle, revisamos cada elemento
		for (int i = 0; i < numeros.length; i++) {
			//Comprobamos si ya hemos leido este valor
			if (leidos.contains(Integer.toString(numeros[i]))) {
				//Ya ha sido leido anteriormente, es un repetido.
				//Si aun no ha está anotado como repetido, lo anotamos ahora
				if (!repetidos.contains(Integer.toString(numeros[i])))
					repetidos = repetidos + Integer.toString(numeros[i]);
 
			}
			else //No es un repetido, lo anotamos como leido para recordarlo
				leidos = leidos + Integer.toString(numeros[i]);
 
		}
 
		//Bucles ha finalizado, tenemos los valores repetidos en un String
		//Hay que construir un nuevo vector de int a partir de ese String
		int[] valores = new int[repetidos.length()];
		for (int i = 0; i < valores.length; i++)
			valores[i] = Integer.parseInt(repetidos.substring(i, i+1));
 
		//Listo, mostramos los resultados.
 
		System.out.println("Array inicial de numeros:");
		System.out.println(Arrays.toString(numeros));
 
		System.out.println("\nValores repetidos encontrados:");
		System.out.println(Arrays.toString(valores));
 
	}
 
}


Ahora sí, en pantalla aparecen en el orden que pedías:
1
2
3
4
5
Array inicial de numeros:
[1, 2, 4, 4, 3, 3, 1, 5, 3, 5]
 
Valores repetidos encontrados:
[4, 3, 1, 5]
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
sin imagen de perfil
Val: 6
Ha aumentado su posición en 3 puestos en Java (en relación al último mes)
Gráfica de Java

Ayuda ejercicio basico java

Publicado por Esther (3 intervenciones) el 24/05/2021 13:42:30
Funciona correctamente
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