Juez LTI

T04-1D-A04. Eliminar repetidos de un array

Enunciado

Escribe un programa en Java que elimine de un array los números enteros que estén repetidos en el mismo, de tal manera que solo dejará el primero de ellos.

Ejemplo:

• Dado el array de enteros {1, 2, 1, 8, 5, 2, 8, 2, 4, 9, 12, 8, 1, 2}, lo transformará en un array: {1, 2, 8, 5, 4, 9, 12}
• Dado el array de enteros {8, 20, 555, 555, 555, 8, 1, 9, 2, 555, 8, 20, 80}, lo transformará en el array: {8, 20, 555, 1, 9, 2, 80}

ENTRADA

La entrada comienza con un número indicando cuántos casos de prueba habrá que procesar.

Cada uno de los casos estará formado por:

• Una primera línea con el número L de elementos del array, donde L > 0
• Una segunda con los L elementos de dicho array separados por un espacio. 

SALIDA

Por cada caso de prueba, el programa escribirá el contenido del array una vez eliminados los números repetidos.

RESTRICCIONES

Se resolverá el problema haciendo uso de la siguiente descomposición funcional:

• Una función que reciba un array de enteros y un número entero positivo como argumento y devuelva la posición del array de la primera aparición de dicho número. La función devolverá -1 si el número pasado como argumento no aparece en el array.
• Una función que reciba un array de enteros como argumento y devuelva otro array distinto en el que se habrán suprimido los números repetidos, de tal manera que cada número aparezca solo una vez, en el mismo orden en el que aparecen en el array original.  ATENCIÓN: Vamos a programar esta función con cuidado, haciendo un uso óptimo de la memoria. Para ello, crearás un array auxiliar del mismo tamaño del original, en el que solo introduciremos los números no repetidos. En este array pueden quedar posiciones vacias (al valor de inicialización), y deberemos llevar la cuenta de cuántas de esas posiciones del array contienen número válidos para la resolución del problema. Una vez que sabemos cuántos son estos número no repetidos, crearemos un nuevo array de dicho tamaño y pasaremos a él los números de la solución. Éste será el array que devolvamos, que tendrá el tamaño justo para la solución buscada. Es decir, NO se puede crear un nuevo array para cada número nuevo no repetido que encontremos.

El programa principal, para cada caso, imprimirá el resultado de rotar la cadena las N posiciones a derecha o a izquierda.

OPTIMIZACIÓN ALGORÍTMICA

JuezLTI no lo va a tener en cuenta a la hora de dar como correcto o no el ejercicio, pero vamos a intentar programar de la manera más óptima posible, reduciendo al máximo el uso de memoria. Para ello, debes observar y plasmar en tu algoritmo, la manera de proceder descrita para la segunda función en la sección de "Restricciones".

											
import java.util.Scanner;

/**
 *
 * @author AulaVirtual
 */
public class EliminarRepetidos {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner sc = new Scanner(System.in);

        int numCasos = 0;
        int arraySize;
        int[] array;
        int [] arraySinRepetidos;
        
        numCasos = sc.nextInt();

        for (int i = 1; i <= numCasos; i++) {
            arraySize = sc.nextInt();
            array = new int[arraySize];

            for (int j = 0; j < array.length; j++) {
                array[j] = sc.nextInt();
            }
            
            arraySinRepetidos = eliminarRepetidos(array);

            for (int j = 0; j < arraySinRepetidos.length; j++) {
                System.out.print(arraySinRepetidos[j] + " ");
            }
            System.out.println();

        }
    }

    public static int primeraAparicionNumero(int[] array, int numero) {
        int posicion = -1;
        int i = 0;

        while (i < array.length && posicion == -1) {
            if (array[i] == numero) {
                posicion = i;
            }
            i++;
        }
        return posicion;
    }

    public static int[] eliminarRepetidos(int[] array) {
        int[] arrayAuxiliar = new int[array.length];
        int[] nuevoArray;
        int ultimoNuevoArray = 0;

        for (int i = 0; i < array.length; i++) {
            if (primeraAparicionNumero(array, array[i]) == i) {
                arrayAuxiliar[ultimoNuevoArray] = array[i];
                ultimoNuevoArray++;
            }
        }
                
        nuevoArray = new int[ultimoNuevoArray];
        for (int i = 0; i < nuevoArray.length; i++) {
            nuevoArray[i] = arrayAuxiliar[i];
        }
        
        return nuevoArray;
    }
}

											

9
14
1 2 1 8 5 2 8 2 4 9 12 8 1 2
13
8 20 555 555 555 8 1 9 2 555 8 20 80
1
97
5
3 3 3 3 3
10
1 2 3 4 5 6 7 8 9 10
10
3 3 3 6 1 3 8 8 8 2
13
9 8 7 6 5 5 5 3 9 8 7 2 3
10
1 2 3 4 5 5 4 3 2 1
13
8 20 0 555 555 8 0 9 2 555 8 20 80

9
14
1 2 1 8 5 2 8 2 4 9 12 8 1 2
13
8 20 555 555 555 8 1 9 2 555 8 20 80
1
97
5
3 3 3 3 3
10
1 2 3 4 5 6 7 8 9 10
10
3 3 3 6 1 3 8 8 8 2
13
9 8 7 6 5 5 5 3 9 8 7 2 3
10
1 2 3 4 5 5 4 3 2 1
13
8 20 0 555 555 8 0 9 2 555 8 20 80

1 2 8 5 4 9 12 
8 20 555 1 9 2 80 
97 
3 
1 2 3 4 5 6 7 8 9 10 
3 6 1 8 2 
9 8 7 6 5 3 2 
1 2 3 4 5 
8 20 0 555 9 2 80

1 2 8 5 4 9 12 
8 20 555 1 9 2 80 
97 
3 
1 2 3 4 5 6 7 8 9 10 
3 6 1 8 2 
9 8 7 6 5 3 2 
1 2 3 4 5 
8 20 0 555 9 2 80

• Anterior
• Siguiente