Java - Números no repetidos JAVA

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

Números no repetidos JAVA

Publicado por Osvaldo (60 intervenciones) el 28/01/2021 22:57:08
Saludos a todos. Deseo su ayuda para comprobar si mi código es el correcto. Es un trabajo asignado en la empresa. También deseo saber si es que hago uso correcto de la indentación. Éxitos a todos.

/* Ingresar un vector de 13 elementos, y crear un nuevo vector que contenga los elementos
del primer vector no repetidos. Imprimir el vector resultante. Si no se cargó ningún
elemento en el nuevo vector imprimir un mensaje aclaratorio.
Ejemplo: Si el vector ingresado contiene: (3,5,5,6,9,9,9,12,12,15,16,18,18)
el vector resultante sería: (3,6,15,16)
OBS: Validar que los elementos del vector sean positivos y se ingresen en orden ascendente.
*/
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
package repetive;
import java.util.Random;
public class Repetive {
    public static void main(String[] args) {
        int[] componentes = new int[13];
        int[] unique = new int[13];
        int i = 0;
        Random rant = new Random();
        int numero = rant.nextInt();
        imprimirUnicos(unique);
        for (int x = 0; x < 13; x++) {
            if (numerosUnicos(componentes[x], componentes));
        }
    }
    public static boolean numerosUnicos(int numero, int[] componentes) {
        int contador = 0;
        for (int x = 0; x < 13; x++) {
            if (componentes[x] == numero) {
                contador++;
            }
        }
        return contador == 1;
    }
    public static void imprimirUnicos(int[] unique) {
        for (int i = 0; i < 13; i++) {
            System.out.println("Elementos no repetidos" + unique[i]);
        }
    }
}
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 Rodrigo
Val: 2.041
Plata
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Números no repetidos JAVA

Publicado por Rodrigo (623 intervenciones) el 28/01/2021 23:29:08
Si el arreglo esta ordenado de manera ascendente, basta chequear con el elemento de adelante para saber si esta repetido o no, Si no esta repetido chequeas el siguiente. Si esta repetido, iteras mientras el siguiente sea igual.

Si la idea del programa es imprimir los que son unicos, haz esto al final del proceso, no antes de procesar como lo tienes ahora.
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: 66
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Números no repetidos JAVA

Publicado por Osvaldo (60 intervenciones) el 01/02/2021 22:39:28
Muchas gracias por la respuesta a mi publicación. Tengo una consulta ¿Cómo imprimo al final del proceso? Es que no encuentro la forma de hacerlo. No tengo los conocimientos para lograr. Por favor espero su ayuda y de los demás miembros de la comunidad.
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 Rodrigo
Val: 2.041
Plata
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Números no repetidos JAVA

Publicado por Rodrigo (623 intervenciones) el 01/02/2021 22:51:15
En el codigo original que publicaste, la linea 10 imprime, pero esta antes del ciclo que en teoria calcula los unicos.
La impresion deberia estar despues del ciclo, no antes.

Luego te tienes que preocupar que el arreglo que contiene los unicos efectivamente se modifique en el ciclo.
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: 66
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Números no repetidos JAVA

Publicado por Osvaldo (60 intervenciones) el 01/02/2021 23:19:23
Esto es lo que logro hacer. Les ruego y suplico por favor sus aportes. Gracias


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
package repetive;
import java.util.Random;
public class Repetive {
    public static void main(String[] args) {
        int[] componentes = new int[13];
        int[] unique = new int[13];
        int i = 0;
        Random rant = new Random();
        int numero = rant.nextInt();
            for (int x = 0; x < 13; x++) {
            if (numerosUnicos(componentes[x], componentes));
        }
    }
    public static boolean numerosUnicos(int numero, int[] componentes) {
        int contador = 0;
        for (int x = 0; x < 13; x++) {
            if (componentes[x] == numero) {
                contador++;
            }
        }
        return contador == 1;
    }
    public static void imprimirUnicos(int[] unique) {
        for (int i = 0; i < 13; i++) {
            System.out.println("Elementos no repetidos" + unique[i]);
        }
    }
}
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

Números no repetidos JAVA

Publicado por Kabuto (1381 intervenciones) el 02/02/2021 01:15:05
Hola.
El objeto Random que usas no te está sirviendo para nada. Si lo querías usar para rellenar el array, tendrías que usarlo dentro de un bucle y pedirle un entero al azar para cada uno de los 13 elementos.

De todos modos, el enunciado parece indicar que los valore se han de ingresar por teclado, y validando que no sean negativos y que se ingresen en orden ascendente.

A continuación te voy a proponer un código que puede servir de solución para lo que se pide.
Tu método para comprobar si un número está repetido, está bien traído y podría haberlo utilizado.
Sin embargo, supone recorrer el vector tantas veces como elementos tiene y esto en otros escenarios podría no ser muy óptimo.
En este caso son 13 elementos, así que no importa demasiado. Pero supongamos que se quiere usar ese mismo método para un vector de 100.000 elementos (en computación se puede llegar a trabajar con vectores de longitudes enormes)
Recorrer 100.000 elementos, unas 100.000 veces.... supondría muchísimos ciclos de computación..

Yo lo he enfocado de otra manera. Puesto que hemos validado el obtener un array ordenado, solo hay que recorrerlo una vez y comparar cada elemento con su anterior y posterior.

Pero, si no tuviéramos un vector ordenado, habría que usar un método como el tuyo, aunque se podría optimizar un poco para reducir iteraciones (cuando contador supere el valor 1, se puede retornar false directamente sin esperar a que termine de recorrer el vector por completo)


Este es mi código, parece que hay muchas líneas pero es por los 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
81
82
import java.util.Scanner;
 
public class Repetive {
 
	public static void main(String[] args) {
 
		Scanner teclado = new Scanner(System.in);
 
		//Creamos vector de números, pidiendo componentes por teclado
		int[] componentes = new int[13];
		for (int i = 0; i < 13; i++) {
			System.out.print("Ingrese número: ");
			int numero = teclado.nextInt();
			//Solo se admiten valores positivos y que sean ingresados en orden ascendente
			if (numero < 0) {
				System.out.println("No se admiten valores negativos");
				i--; //Valor rechazado, corregimos indice para que vuelva a pedirse este componente
			}
			//Ahora comprobamos si este valor es menor que el anterior introducido.
			//Pero solo lo comprobaremos si este NO ES el primer valor que se introduce
			else if ( i > 0 && numero < componentes[i-1]) {
				System.out.println("No se admite un valor menor que el anterior introducido");
				i--;
			}
			else //No es negativo y no es menor que el anterior, o bien se trata del primer elemento que se introduce
				componentes[i] = numero; //Lo aceptamos
		}
 
		/*
		 * Ya tenemos 13 valores introducidos y hemos validado que sean positivos y
		 * recibidos en orden ascendente.
		 * Ahora crearemos nuevo vector, solo con los valores no repetidos.
		 */
		int[] unique = new int[13];
		/*
		 * El vector de "únicos" tendrá un indice que iremos incrementando
		 * manualmente solo cuando reciba un nuevo valor.
		 */
		int indiceUnico = 0;
		/*
		 * Para buscar repetidos, como están en orden, podemos recorrer
		 * cada número y comprobar si tanto el anterior como el posterior son distintos.
		 * Excepto si estamos en el primer elemento, que solo compararemos con el posterior
		 * o si estamos en el último elemento, que solo compararemos con el anterior.
		 */
		for (int i = 0; i < 13; i++) {
			if (i == 0 && componentes[i] != componentes[i+1]) {
				unique[indiceUnico] = componentes[i]; //Aceptado
				indiceUnico++; //Incrementamos indice de "únicos"
			}
			else if (i == 12 && componentes[i] != componentes[i-1]) {
				unique[indiceUnico] = componentes[i];
				indiceUnico++;
			}
			else if (componentes[i] != componentes[i-1] && componentes[i] != componentes[i+1]) {
				unique[indiceUnico] = componentes[i];
				indiceUnico++;
			}
		}
		/*
		 * Tras este bucle for, ya deberíamos tener solo los elementos únicos.
		 * La variable indiceUnico nos dice cuántos de estos elementos hemos obtenido
		 */
		//Mostramos primero vector original
		System.out.println("\nVector ingresado:");
		for (int valor: componentes)
			System.out.print(valor + " ");
 
		//Ahora mostramos vector de valores únicos, si es que hemos encontrado alguno.
		if (indiceUnico == 0)
			System.out.println("\n\nNo se han encontrado valores únicos en el vector ingresado");
		else {
			System.out.println("\n\nValores únicos encontrados:");
			for (int i = 0; i < indiceUnico; i++)
				System.out.print(unique[i] + " ");
		}
 
		System.out.println("\n\n\t\tFIN DE PROGRAMA");
		teclado.close();
	}
 
}

Y esto es una prueba del programa en pantalla, introduciendo los mismos elementos que propone el enunciado como ejemplo para comprobar que se cumple la salida esperada:
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
Ingrese número: -6
No se admiten valores negativos
Ingrese número: 3
Ingrese número: 5
Ingrese número: 1
No se admite un valor menor que el anterior introducido
Ingrese número: 5
Ingrese número: 6
Ingrese número: 9
Ingrese número: 9
Ingrese número: 9
Ingrese número: 12
Ingrese número: 12
Ingrese número: 15
Ingrese número: 16
Ingrese número: 18
Ingrese número: 4
No se admite un valor menor que el anterior introducido
Ingrese número: 18
 
Vector ingresado:
3 5 5 6 9 9 9 12 12 15 16 18 18
 
Valores únicos encontrados:
3 6 15 16
 
		FIN DE PROGRAMA
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
Imágen de perfil de Rodrigo
Val: 2.041
Plata
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Números no repetidos JAVA

Publicado por Rodrigo (623 intervenciones) el 02/02/2021 01:51:35
Ignorar este comentario. Lo edite porque estaba criticando el problema como si se estuviera resolviendo el problema de poner solo 1 vez los numeros que se repiten.
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: 66
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Números no repetidos JAVA

Publicado por Osvaldo (60 intervenciones) el 05/02/2021 22:35:36
Eternamente agradecido.
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