Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » ejercicio de tic AYUDA!!!

Java - ejercicio de tic AYUDA!!!

Volver
Nuevo Tema
<<>>
 
Vista:

ejercicio de tic AYUDA!!!

Publicado por pablo (4 intervenciones) el 02/06/2020 16:23:24
Hola, estoy haciendo un ejercicio para clase y ya no sé por donde cogerlo...

2.- Introducir un número: Si el usuario selecciona esta opción se debe de pedir al usuario que introduzca un número entero y se introducirá el número en el array de forma que quede ordenado. Por ejemplo si el array tenía los valores {1,2, 7 9} y el usuario introduce un 4, el array al final debería de quedar {1, 2, 4, 7, 9}. Si el usuario introduce un 2, se debería de indicar al usuario que el número ya estaba en el array y lo deja como está.

3.- Borrar un número: Debe preguntar al usuario el número a borrar. Si el número no estaba en el array se lo indicará al usuario. Si estaba se debe eliminar ese elemento del array.

si alguien sabe que me ayude, gracias.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
-2
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 tic AYUDA!!!

Publicado por Kabuto (1385 intervenciones) el 02/06/2020 20:19:48
Un array no se puede modificar, son ESTÁTICOS.

Se puede crear un nuevo con los valores del array original, más el nuevo número que hay que insertar (o menos el número que hay que borrar) colocándolo en el orden adecuado.
Luego ese nuevo array, se referencia con el nombre del array original y se simula que ha sido modificado.

Te dejo un código con el menú y un método para insertar un valor.
Parece que hay mucho código pero es porque hay muchas líneas de comentarios.

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
public class Main {
 
	private static int[] array = {1, 2, 7, 9};
 
	public static void main(String[] args) {
		Scanner teclado = new Scanner(System.in);
		int opcion = 0;
 
		do {
			System.out.println("\n[1] - Mostrar Array");
			System.out.println("[2] - Insertar número");
			System.out.println("[3] - Borrar número");
			System.out.println("[0] - FIN DE PROGRAMA");
			System.out.print("Elija opción: ");
			opcion = teclado.nextInt();
 
			switch (opcion) {
			case 0:
				System.out.println("\n\t\t--FIN DE PROGRAMA--");
				break;
			case 1:
				System.out.println("\nArray Actual -> " + Arrays.toString(array));
				break;
			case 2:
				System.out.println("Número a insertar: ");
				insertar(teclado.nextInt());
				break;
			case 3:
				//TODO: Metodo para borrar
				break;
			default:
				System.out.println("\nOpcion errónea...");
			}
 
		}while(opcion != 0);
 
		teclado.close();
	}
 
	/**
	 * Método para insertar un nuevo número en el array de forma ordenada
	 * @param num Valor int que vamos a insertar
	 */
	private static void insertar(int num) {
		//Comprobamos si ya está
		for (int in = 0; in < array.length; in++)
			if (array[in] ==  num) {
				System.out.println("Este número ya existe");
				return; //Método finaliza
			}
		//No está, habrá que insertarlo en orden.
		//Los arrays no se pueden modificar, habrá que crear uno nuevo
		int[] nuevoArray = new int[array.length + 1]; //Mismo tamaño que el original + 1
		//Necesitaremos dos indices distintos para cada array.
		//El del array nuevo lo incrementará el bucle for
		//El del original, indice j,  lo incrementaremos manualmente cuando cojamos un número suyo
		int j = 0;
		//Con un boolean controlaremos si ya hemos insertado el nuevo valor.
		//Así sabremos que ya los números originales que quedan se pueden coger sin comparar
		boolean insertado = false;
		for (int in = 0; in < nuevoArray.length; in++) {
			/*
			 * Seleccionamos número del original, si es menor que el
			 * numero que hay que insertar, cogemos el original.
			 * De lo contrario, insertaremos el nuevo número
			 */
			if (insertado || array[j] < num) { //Si nuevo num ya esta insertado o array original tiene un menor a num
				nuevoArray[in] = array[j]; //Cogemos numero del original
				j++; //Incrementamos su indice
			}
			else {
				nuevoArray[in] = num; //Ya se han cogido los valores menores al nuevo. Ahora le toca a él.
				insertado = true; //Registramos que ya ha sido insertado
			}
		}
		//Listo, ahora referenciamos el nuevo array con la referencia original
		array = nuevoArray;
	}
 
}

En pantalla podemos comprobar que funciona. Pero en realidad tiene un defecto que comento luego.
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
[1] - Mostrar Array
[2] - Insertar número
[3] - Borrar número
[0] - FIN DE PROGRAMA
Elija opción: 1
 
Array Actual -> [1, 2, 7, 9]
 
[1] - Mostrar Array
[2] - Insertar número
[3] - Borrar número
[0] - FIN DE PROGRAMA
Elija opción: 2
Número a insertar: 3
 
[1] - Mostrar Array
[2] - Insertar número
[3] - Borrar número
[0] - FIN DE PROGRAMA
Elija opción: 1
 
Array Actual -> [1, 2, 3, 7, 9]
 
[1] - Mostrar Array
[2] - Insertar número
[3] - Borrar número
[0] - FIN DE PROGRAMA
Elija opción: 2
Número a insertar: 8
 
[1] - Mostrar Array
[2] - Insertar número
[3] - Borrar número
[0] - FIN DE PROGRAMA
Elija opción: 1
 
Array Actual -> [1, 2, 3, 7, 8, 9]
 
[1] - Mostrar Array
[2] - Insertar número
[3] - Borrar número
[0] - FIN DE PROGRAMA
Elija opción: 0
 
		--FIN DE PROGRAMA--

Parece que funciona, pero hay un defecto de lógica.
Antes de explicarlo, me gustaría que leyeses el código a fondo y que comprendieses más o menos como funciona y que hace.

Una vez entiendes como funciona, también entenderás fácilmente cuál es el (pequeño) error de lógica.
Fíjate que pasa si insertamos un nuevo número que iría al final del array por ser mayor que todos los números actuales.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
[1] - Mostrar Array
[2] - Insertar número
[3] - Borrar número
[0] - FIN DE PROGRAMA
Elija opción: 1
 
Array Actual -> [1, 2, 7, 9]
 
[1] - Mostrar Array
[2] - Insertar número
[3] - Borrar número
[0] - FIN DE PROGRAMA
Elija opción: 2
Número a insertar: 10
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4
	at insertarEnArrayOrdenado.Main.insertar(Main.java:72)
	at insertarEnArrayOrdenado.Main.main(Main.java:31)

¡¡Pumm!!. Error.
¿Por qué?
Si has leído y entendido el código, verás que estamos permitiendo que la variable j, la que sirve de indice para recorrer las posiciones del array original, alcance un valor mayor que los límites de su array. Y esto produce una Exception (excepción)
En el método tenemos que recorrer dos arrays de distinto tamaño, y entonces estos errores pueden suceder.

Para evitarlo, podemos usar un try catch para capturar la excepción y evitar que el programa se "rompa" cuando esto suceda.

O si no, cosa que yo prefiero, asegurarnos de que no habrá lugar a esta excepción ampliando las condiciones del if y preguntando si j ya ha alcanzado el límite máximo. Si esto es cierto, ya solo queda añadir el nuevo valor.
El método ahora quedaría así. Marco en negrita los cambios.
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
private static void insertar(int num) {
		//Comprobamos si ya está
		for (int in = 0; in < array.length; in++)
			if (array[in] ==  num) {
				System.out.println("Este número ya existe");
				return; //Método finaliza
			}
		//No está, habrá que insertarlo en orden.
		//Los arrays no se pueden modificar, habrá que crear uno nuevo
		int[] nuevoArray = new int[array.length + 1]; //Mismo tamaño que el original + 1
		//Necesitaremos dos indices distintos para cada array.
		//El del array nuevo lo incrementará el bucle for
		//El del original, indice j,  lo incrementaremos manualmente cuando cojamos un número suyo
		int j = 0;
		//Con un boolean controlaremos si ya hemos insertado el nuevo valor.
		//Así sabremos que ya los numeros originales que quedan se pueden coger sin comparar
		boolean insertado = false;
		for (int in = 0; in < nuevoArray.length; in++) {
			/*
			 * Seleccionamos número del original, si es menor que el
			 * numero que hay que insertar, cogemos el original.
			 * De lo contrario, insertaremos el nuevo número
			 */
			if (j == array.length) { //Array original ha terminado, no quedan números por coger
				nuevoArray[in] = num; //Directamente insertamos nuevo valor,esta es la última iteración del bucle
			}
			else if (insertado || array[j] < num) { //Si nuevo num ya esta insertado o array original tiene un menor a num
				nuevoArray[in] = array[j]; //Cogemos numero del original
				j++; //Incrementamos su indice
			}
			else {
				nuevoArray[in] = num; //Ya se han cogido los valores menores al nuevo. Ahora le toca a él.
				insertado = true; //Registramos que ya ha sido insertado
			}
		}
		//Listo, ahora referenciamos el nuevo array con la referencia original
		array = nuevoArray;
	}

Bien, si has entendido bien la mecánica que se sigue, deberías poder hacer tú un método que haga lo de "borrar" número del array. Es más fácil que añadir.
Si te atascas, tienes dudas, algo no lo entiendes... pregunta por aquí, comparte el código que hayas escrito aunque no funcione, y te ayudamos a completarlo.
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

ejercicio de tic AYUDA!!!

Publicado por pablo (4 intervenciones) el 02/06/2020 21:06:33
yo creo que esta así bien
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
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
 
public class AAA {
 
	public static void main(String args[])
	{
		ArrayList<Integer> arrayNumerosIntroducidos = new ArrayList<Integer>();
		Scanner sn = new Scanner(System.in);
		boolean  acabar = false;
 
	       while(!acabar){
 
	           System.out.println("1. Mostrar contenido array");
	           System.out.println("2. Introducir numero entero en array");
	           System.out.println("3. Borrar número");
	           System.out.println("4. Salir");
	           System.out.println("Seleccione una opción:");
	   		   int opcionSeleccionada = sn.nextInt();
 
	           switch(opcionSeleccionada){
	               case 1:
	            	   System.out.println("Has seleccionado la opcion 1");
	           			if(arrayNumerosIntroducidos == null || arrayNumerosIntroducidos.isEmpty())
	           			{
	           				System.out.println("El array esta vacio \n");
	        			}
	           			for (Integer numero: arrayNumerosIntroducidos)
	        			{
	           				System.out.println(numero.toString());
	        			}
	                   break;
	               case 2:
	                   System.out.println("Has seleccionado la opcion 2");
	                   System.out.println("Introduce un numero: ");
 
	                   int numeroIntroducido = sn.nextInt();
	           			if (arrayNumerosIntroducidos.contains(numeroIntroducido))
	           			{
	           			 System.out.println("El número introducido ya existia en el array");
	           			}
	           			else
	           			{
	           			arrayNumerosIntroducidos.add(numeroIntroducido);
	           			Collections.sort(arrayNumerosIntroducidos);
	           			}
	                   break;
	                case 3:
	                	System.out.println("Introduce un numero para borrar en el array: ");
	                	 int numeroABorrar = sn.nextInt();
	                	 if (!arrayNumerosIntroducidos.contains(numeroABorrar))
	                	 {
	                		 System.out.println("El numero no se ha encontrado");
	                	 }
	                	 else
	                	 {
 
	                		 arrayNumerosIntroducidos.removeAll(Arrays.asList(numeroABorrar));
	                	 }
 
	                   System.out.println("Has seleccionado la opcion 3");
	                   break;
	                case 4:
	                	acabar=true;
	                   break;
	                default:
	                   System.out.println("No ha seleccionado una ópcion valida");
 
	           }
	       }
   		   sn.close();
	}
 
}
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

ejercicio de tic AYUDA!!!

Publicado por Kabuto (1385 intervenciones) el 02/06/2020 21:16:01
Ojo, una cosa es un array y otra cosa es un ArrayList.

El enunciado parece que hace referencia al primero, a un array primitivo. De ahí que el código tenga sus complicaciones porque como dije, estos arrays son inmutables, no se pueden alterar.

Los ArrayList son listas dinámicas, pueden crecer y decrecer, y además son clases POO por lo que ofrecen varios métodos que facilitan mucho las cosas.

No se si la intención de este ejercicio es más bien cogerle práctica a usar arrays primitivos.
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

ejercicio de tic AYUDA!!!

Publicado por pablo (4 intervenciones) el 02/06/2020 22:25:27
no se como areglarlo bien. Java es una mierda. y las matrices y vectores mas. Así se lo voy a decir al profe xd
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