Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » Eliminar primer ocurrencia de numero en arreglo

Java - Eliminar primer ocurrencia de numero en arreglo

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil
Val: 11
Ha aumentado su posición en 3 puestos en Java (en relación al último mes)
Gráfica de Java

Eliminar primer ocurrencia de numero en arreglo

Publicado por flor (4 intervenciones) el 12/05/2021 22:11:42
¡Hola! ¿Alguien me puede ayudar con este ejercicio? No estoy segura de cómo realizar la parte de "elimine la primer ocurrencia de numero en el arreglo". Posteo lo que tengo hecho, pero seguro hay cosas que están mal. Desde ya, ¡muchas gracias!
consigna: Hacer un programa que dado un arreglo de enteros de tamaño 10 que se encuentra
precargado, solicite al usuario un numero entero y elimine la primer ocurrencia de numero (un
número igual) en el arreglo si existe. Para ello tendrá que buscar la posición y si está, realizar un
corrimiento a izquierda (queda una copia de la última posición del arreglo en la anteúltima
posición)


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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Random;
public class Clase_7_ejercicio_5 {
	public static int MAX=10;
	public static int MAXVALOR=10;
	public static int MINVALOR=1;
	public static void main(String[] args) {
		int [] arrenteros=new int [MAX];
		int numero, pos=0;
		BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
 
		try {
			cargar_arreglo_aleatorio(arrenteros);
			imprimir_arreglo_aleatorio(arrenteros);
			System.out.println("Ingrese un numero entero: ");
			numero=Integer.valueOf(entrada.readLine());
 
 
			buscar_numero_igual(arrenteros, numero);
		        corrimiento_izq(arrenteros, pos);
			imprimir_arreglo_aleatorio(arrenteros);
 
			}
 
 
		catch (Exception exc) {
			System.out.println(exc);
		}
	}
	public static void cargar_arreglo_aleatorio(int [] arr) {
		Random r = new Random();
		for (int pos = 0; pos < MAX; pos++){
		arr[pos]=(r.nextInt(MAXVALOR-MINVALOR+1) + MINVALOR);
		}
	}
	public static void imprimir_arreglo_aleatorio(int [] arr) {
		for (int pos = 0; pos < MAX; pos++){
			System.out.println("nombre_arreglo["+pos+"]=>: "+arr[pos]);
			}
	}
	public static void buscar_numero_igual (int [] arr, int numero) {
		for (int pos = 0; pos < MAX; pos++){
			if (numero==arr[pos]) {
	                    arr[pos]=arr[pos+1]; //?????
			}
		}
	}
 
 
	public static void corrimiento_izq(int [] arr, int pos) {
		int indice=0;
		while (indice<pos) {
			arr[indice]=arr[indice+1];
			indice++;
 
	}
 
}
}
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 Billy Joel
Val: 2.665
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Eliminar primer ocurrencia de numero en arreglo

Publicado por Billy Joel (878 intervenciones) el 12/05/2021 23:05:53
Se me ocurre algo así:
1
2
3
4
5
6
7
8
9
10
11
12
public static int[] eliminarPrimerOcurrencia(int[] a, int buscar) {
    for (int i = 0; i < a.length; i++) {
        if (a[i] == buscar) {
            for (int j = i; j < a.length; j++) {
                if (j + 1 < a.length) {
                    a[j] = a[j + 1];
                }
            }
        }
    }
    return a;
}

Lo puedes probar así:
1
2
3
4
5
6
7
8
public static void main(String[] args) {
    int[] a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int buscar = 4;
    int[] b = eliminarPrimerOcurrencia(a, buscar);
    for (int i = 0; i < b.length; i++) {
        System.out.print(b[i] + (i + 1 < b.length ? ", " : "\n"));
    }
}

Te dejo la captura de los datos a ti

Saludos,
Billy Joel
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
2
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

Eliminar primer ocurrencia de numero en arreglo

Publicado por Kabuto (1385 intervenciones) el 12/05/2021 23:27:15
También puedes hacer que el método buscar_numero_igual() en lugar de ser void, te retorne un int. Y que este int sea la posición donde se encuentra la primera coincidencia.
Si no existe ninguna coincidencia, podemos hacer que retorne -1 y así sabemos si es necesario hacer el corrimiento o no.

1
2
3
4
5
6
7
8
9
public static int buscar_numero_igual (int[] arr, int numero) {
 
    for (int pos = 0; pos < MAX; pos++){
        if (numero==arr[pos])
            return pos; //A la primera coincidencia, retornamos posicion
    }
 
    return -1; //Si el bucle FOR no ha encontrado ninguna coincidencia, retornamos -1
}

Bien, ahora tendríamos en un int la posición del número que hay que borrar y a partir del cuál hacer el corrimiento.
El método para hacer esto, es super sencillo:
1
2
3
4
5
public static void corrimiento_izq(int[] arr, int pos) {
 
    for (int c = pos + 1; c < MAX; c++)
        arr[c - 1] = arr[c];
}
El bucle comienza a contar en una posición posterior al número a borrar. Y el número de esa posición, se corre a la izquierda (una posición anterior) eliminando así el número que hay que borrar.
Es decir, si la posición es 4, pues comenzamos moviendo el 5 al 4, el 6 al 5, el 7 al 6, etc...

Ahora que tenemos estos dos métodos, en el main lo que haremos será recoger el int que nos devuelva el primer método.
Si es -1, informamos de que no existe ese valor en el array.
Si no, pues usamos ese int para hacer el corrimiento y mostramos en pantalla el array resultante:

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
public static void main(String[] args) {
    int [] arrenteros=new int [MAX];
    int numero, pos=0;
    BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
 
    try {
        cargar_arreglo_aleatorio(arrenteros);
        imprimir_arreglo_aleatorio(arrenteros);
        System.out.println("Ingrese un numero entero: ");
        numero=Integer.valueOf(entrada.readLine());
 
 
        //Buscamos una posicion que coincida
        pos =  buscar_numero_igual(arrenteros, numero);
        //Comprobamos si ha habido coincidencia
        if (pos == -1)
            System.out.println("EL numero introducido no existe en el array");
        else {
            //Tenemos posicion de una coincidencia, hacemos corrimiento
            corrimiento_izq(arrenteros, pos);
            imprimir_arreglo_aleatorio(arrenteros);
        }
 
    }
 
 
    catch (Exception exc) {
        System.out.println(exc);
    }
}


Si hacemos la prueba veremos en pantalla que funciona correctamente:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
nombre_arreglo[0]=>: 1
nombre_arreglo[1]=>: 2
nombre_arreglo[2]=>: 9
nombre_arreglo[3]=>: 7
nombre_arreglo[4]=>: 7
nombre_arreglo[5]=>: 3
nombre_arreglo[6]=>: 3
nombre_arreglo[7]=>: 1
nombre_arreglo[8]=>: 2
nombre_arreglo[9]=>: 7
Ingrese un numero entero:
9
nombre_arreglo[0]=>: 1
nombre_arreglo[1]=>: 2
nombre_arreglo[2]=>: 7
nombre_arreglo[3]=>: 7
nombre_arreglo[4]=>: 3
nombre_arreglo[5]=>: 3
nombre_arreglo[6]=>: 1
nombre_arreglo[7]=>: 2
nombre_arreglo[8]=>: 7
nombre_arreglo[9]=>: 7


Solo hay un pequeño "fallo". Aunque en realidad no lo és, porque es debido precisamente a la lógica que pide el enunciado.
Si el número que coincide, está en la última posición, pues entonces no ocurre nada. Porque no hay nada a la derecha de ese número que podamos correr a la izquierda.
Por ejemplo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
nombre_arreglo[0]=>: 10
nombre_arreglo[1]=>: 2
nombre_arreglo[2]=>: 7
nombre_arreglo[3]=>: 9
nombre_arreglo[4]=>: 5
nombre_arreglo[5]=>: 6
nombre_arreglo[6]=>: 5
nombre_arreglo[7]=>: 9
nombre_arreglo[8]=>: 1
nombre_arreglo[9]=>: 8
Ingrese un numero entero:
8
nombre_arreglo[0]=>: 10
nombre_arreglo[1]=>: 2
nombre_arreglo[2]=>: 7
nombre_arreglo[3]=>: 9
nombre_arreglo[4]=>: 5
nombre_arreglo[5]=>: 6
nombre_arreglo[6]=>: 5
nombre_arreglo[7]=>: 9
nombre_arreglo[8]=>: 1
nombre_arreglo[9]=>: 8

El array no ha cambiado, pero es por lo que he explicado, después del 8 no hay nada que podamos correr a la izquierda y así eliminar el 8.
El enunciado no contempla esta posibilidad, así que no tiene mayor importancia, solo lo he comentado por curiosidad.

Aunque podemos darle solución por nuestra cuenta, por ejemplo, sustituir ese último número por el primero de todos.
No es necesario hacerlo, porque no lo pide ni lo contempla el enunciado. Pero si quieres llevar el ejercicio un poco más allá, puedes intentarlo por tu cuenta.

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
2
Comentar
sin imagen de perfil
Val: 11
Ha aumentado su posición en 3 puestos en Java (en relación al último mes)
Gráfica de Java

Eliminar primer ocurrencia de numero en arreglo

Publicado por flor (4 intervenciones) el 13/05/2021 02:40:52
Geniooo! Muchas gracias! Saludos
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