Tengo el siguiente código:

import java.util.Scanner;
public class ArrayDuplicates {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("How many numbers are you going to enter? ");
        int num = scan.nextInt();
        int[] arr = new int[num]; //initialize array with user inputted length
        for (int i = 0; i < arr.length; i++) { //enter numbers into array
            arr[i] = scan.nextInt();
        }

        int[] unique = new int[arr.length];    //initialize new array that will hold unique values
        for (int i = 0; i < arr.length; i++) {
            boolean b = true;    //boolean that checks if an element is a duplicate
            for (int j = i+1; j < arr.length; j++) {    //check all elements above int i
                if (arr[i] == arr[j]) {
                    b = false;    //set b to false if there is an existing duplicate
                }
            }
            if (b) {
                unique[i] = arr[i];    //if no duplicates exist, then it is unique.
            }
        }   
        for (int i = 0; i < unique.length; i++) {
                System.out.println(unique[i]);
        }
    }
}

El problema con este código (aparte de ser terriblemente lento para grandes matrices, pero ese no es el punto) es que ya no declarado elementos para la unique matriz se establece en 0, el duplicado de los elementos de la primera matriz se establece en 0 en unique[] (si eso tiene algún sentido). Puedo entender por qué sucede esto, pero no puede encontrar una manera eficaz de corregir esto. He probado la configuración de los elementos duplicados para Integer.MIN_VALUE en el conjunto único y, a continuación, imprimir sólo los elementos de unique[] que no son iguales a Integer.MIN_VALUE, pero eso me parece una solución débil del problema. ¿Cómo puedo solucionar este problema?

EDICIÓN: Si puedo ejecutar el código:

Cuántos números que vas a ingresar? 4

1

2

2

0

De salida:

1
0
2
0

Desde el segundo elemento de la matriz es un duplicado, no me fije unique[1] a cualquier valor, lo que es el valor predeterminado de 0. ¿Cómo puedo evitar la impresión de que 0, ya que no es parte de la matriz original?

EDIT 2: Sí, esta es la tarea, pero la razón por la que no quiero utilizar conjuntos, clasificación, etc. es principalmente que no estoy familiarizado con ellos. También, como no estoy pidiendo a nadie a escribir el programa completo para mí, creo que es bueno para pedir un poco de ayuda.

  • Im miedo de que eso no tiene ningún sentido para mí, tal vez usted podría reformular lo que está tratando de decir en tu pregunta?
  • Han considerado que la no adición de duplicados a la matriz en el primer lugar?
  • Se podían contar los elementos únicos en arr antes de la creación de la unique matriz
  • Sin el uso de una Lista o Conjunto de la solución se vuelve muy desordenado. Si usted no es el uso de una Lista o Conjunto, acababa de sugerir la configuración de los valores duplicados a Entero.MIN_VALUE, como usted lo dijo, o la creación de un paralelo de valores booleanos
  • Java arrays no son dinámicamente el tamaño, por lo que no se puede quitar un elemento sin más código. También, el Map o List no son un Set o de la clasificación.
  • «Creo que es bueno para pedir un poco de ayuda.» – Mi ayuda es en la forma de consejos. Aprender a utilizar el IDE del depurador. En serio.
  • No hay bugs/errores con el programa. Simplemente me estaba preguntando cómo podría mejorar mi código y/o hacerla más eficiente.
  • Mi solución a continuación le permite introducir cualquier valor entero, incluso, negativa. Es su propio código, pero optimizado y se ha añadido un paralelo de la matriz de comparaciones.

InformationsquelleAutor Kootling | 2014-10-25

10 Comentarios

  1. 3

    Voy a usar las herramientas que se utilizan para resolver el problema, porque algo en mí me está diciendo esta es la tarea…

    import java.util.Scanner;
    public class ArrayDuplicates 
    {
    public static void main(String[] args) 
    {
    Scanner scan = new Scanner(System.in);
    System.out.print("How many numbers are you going to enter? ");
    int num = scan.nextInt();
    int[] arr = new int[num]; //initialize array with user inputted length
    for (int i = 0; i < arr.length; i++)//enter numbers into array
    {
    arr[i] = scan.nextInt();
    }
    double[] unique = new double[arr.length];    //initialize new array that will hold unique values
    ///////My edit
    for(int z = 0; z < unique.length; z++)
    {
    unique[z] = -0.5;
    }
    ///////
    for (int i = 0; i < arr.length; i++) 
    {
    boolean b = true;    //boolean that checks if an element is a duplicate
    for (int j = i+1; j < arr.length; j++)    //check all elements above int i
    {
    if (arr[i] == arr[j]) 
    {
    b = false;    //set b to false if there is an existing duplicate
    }
    }
    if (b) 
    {
    unique[i] = arr[i];    //if no duplicates exist, then it is unique.
    }
    }   
    for (int i = 0; i < unique.length; i++) 
    {
    if(!(unique[i] == -0.5))
    {
    System.out.println((int)(unique[i]));
    }
    }
    }
    }

    Así que, ven a lo que me comentó mi edición? esa es la cosa nueva, una manera muy fácil de comprobar es dar a los valores de un número que es no era de esperar, en este caso, un número negativo. Ahora, esa es una suposición de mi parte, el cambio de -1 a cualquier valor que usted sabe que le no de introducirse en la que Scanner. Mismo para la instrucción if.

    • Esta respuesta tiene más sentido para mí, ya que es lo que yo pensaba hacer en un principio. Sin embargo, no sé en qué valores se no se puede entrar, así que me decidí a usar un double array y uso 0.5 como el valor que no se ha introducido (el ingresado los valores deben ser números enteros, así 0.5 no debe ser introducido).
    • Ahhhhhh, buena idea, voy a editar mi respuesta ahora
  2. 4

    Cualquier valor que usted elija (cero, min-int max-int) para representar a la retirada de un duplicado es un problema. El usuario siempre puede entrar en ese número, y el programa no se comportan correctamente. (La única forma en que podría legítimamente usar (por ejemplo) min-int o max-int sería si los requisitos dijo claramente que ese número no válido de entrada.)

    La manera correcta de lidiar con los duplicados es mantener un contador de la cantidad de no duplicados, y asegúrese de que los duplicados (o ranuras que contienen) están en el extremo superior de la matriz; es decir, los índices >= el contador. (Que se convierte en un invariante que su algoritmo necesita para mantener …)

    La mejor solución es eliminar los duplicados antes de agregar a la matriz. Mantener un recuento del número de no-duplicados y repetir hasta que llega a su num … en lugar de la longitud de la matriz.

    Pero si se desea añadir todos los valores a la matriz y luego eliminar los duplicados, cuando usted encuentra un duplicado necesita intercambiar los elementos de modo que usted puede mantener el invariante. La lógica es un poco complicado … pero bastante factible.

    ACTUALIZACIÓN

    Me di cuenta de que su solución original fue el uso de dos matrices. Supuse que estaba utilizando una matriz, y haciendo una actualización en contexto para eliminar los duplicados.

    • Eso es cierto, y tengo que admitir, que es un error en mi respuesta, pero el OP admitió que esta es la tarea y sólo quiere una respuesta que utiliza herramientas de la OP sabe cómo usar y se puede tratar con un conjunto razonable de los insumos. Su punto sigue siendo válido, sólo que esta es la tarea que las respuestas son atontada
    • «La idea de tener una calidad de respuesta para que cualquiera lo use.» – La calidad de la respuesta a los requerimientos funcionales (como se indica) es no utilizar una matriz en absoluto. (El uso de una matriz no es un funcional requisitos. Es una implementación de la restricción … que no tiene mucho sentido para cualquier persona tratando de escribir código de calidad para Java SE, EE, Android.)
    • Así que lo que yo entiendo es que me debe comprobar cada ingresado entero con las anteriores entradas y sólo agregarlo a la matriz original si es única. También tiene un contador que cuenta cuántas entradas se han añadido a la matriz (es decir, los insumos que son únicos). A continuación, crear una nueva matriz de longitud counter que contiene el primer counter elementos de la matriz original. Es esto lo que usted está diciendo? En este caso no iba a necesitar para asegurarse de que los duplicados se encuentran cerca de la final de la matriz, ¿correcto?
    • Ningún comentario. Mi respuesta era en realidad para la OP … en la esperanza de que él iba a intentar hacer la tarea a sí mismo. Pero no dude en enviar su propia respuesta a la maestra, y le pide que le marca para usted 🙂
    • Has entendido lo que yo estaba diciendo.
    • Gracias. Sin embargo ¿por qué el estado que tendría que make sure that the duplicates...are at the high end of the array?
    • Tal vez me misspoke. Depende de si usted eliminar los duplicados antes o después. En el primer caso, estás en lo correcto. Los duplicados no debería estar en la matriz del todo, y las ranuras mayor que el de ‘count’ posición puede ser dejado en su estado inicial. (Simplemente no imprime …) de todos Modos, usted debe pensar que todos a través de usted mismo en lugar de tomar mi (o cualquier otro) palabra para ella.

  3. 2

    La mejor manera de hacer esto es usar un Mapa.

    public interface Map<K,V>

    Un objeto que se asigna teclas de valores. Un mapa no puede contener duplicados
    claves; cada tecla se puede asignar a más de un valor.

    No sé por qué usted no desea utilizar un conjunto a menos que usted está haciendo la tarea…


    Si usted realmente no puede utilizar un conjunto. Seguir adelante y crear un ArrayList. Almacenar los elementos de la array en el interior, pero cada vez que usted desea almacenar comprobar si el elemento ya es parte de la ArrayList.

     int [] list = {5, 5, 3, 2, 5, 3, 5};
    ArrayList<Integer> list2 = new ArrayList<Integer>();
    for(int i = 0; i < list.length; i++)
    if(!list2.contains(list[i]))
    list2.add(list[i]);

    Usted puede, si lo desea, gire el ArrayList de nuevo en una matriz.

    Object[] list3 = list2.toArray();
    • Me temo que en realidad puede ser el caso, de que esta es la tarea.
    • Yo sé cómo hacerlo con un ArrayList, pero wow un Map es tan limpio.
    • Es una herramienta que fue construido para este tipo de cosas
    • Sí, esta es la tarea, pero la razón por la que no quiero utilizar conjuntos, clasificación, etc. es principalmente que no estoy familiarizado con ellos. También, como no estoy pidiendo a nadie a escribir el programa completo para mí, creo que es bueno para pedir un poco de ayuda.
    • hacerlo con un ArrayList como lo hice anteriormente.
    • ¿sabes cómo usar ArrayList, o estás familiarizado con ella?
    • Por desgracia no, no he ido a más de ArrayLists todavía.
    • Tal vez mi respuesta podría ayudar? Desplácese hacia abajo un poco
    • acabo de leer lo que un ArrayList es: docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html En resumen es una más potente de la gama.
    • Perhaps my answer might help? Scroll down a little @DreadHeadedDeveloper totalmente rescatados mi post, pero yo no odio a usted mientras OP aprende 🙂

  4. 1

    Puede almacenar el máximo valor introducido por el usuario (mientras el usuario está introduciendo los valores en la primera vuelta) y, a continuación, hacer que el valor predeterminado para único es igual a max + 1.

    O usted puede intentar otro enfoque para resolver el problema, algo como esto:

      int num = scan.nextInt();
    int[] arr = new int[num];
    int[] uniq = new int[num+1000000];
    int j = 0;
    //enter numbers into array
    for (int i = 0; i < arr.length; i++) { 
    int input = scan.nextInt(); 
    if(uniq[input] != 1){
    uniq[input] = 1;  
    arr[j] = input;
    j++;
    }
    } 
    for (int i = 0; i < j; i++) {
    System.out.println(arr[i]);
    }

    Tenga en cuenta que esta solución es bajo el supuesto de que el usuario no introduce un número mayor que (num + 1,000,000).

    • Hmmmm, el OP está preocupado acerca de la ineficiencia, tengo que dar un -1 por falta de eficiencia, ya que es algo que el OP preguntó específicamente para…
    • Pero esto sólo toma O(num + j).. Así que en realidad esto es más eficiente 🙂
    • Que no significa nada, a la hora de crear un millón de unidad de longitud de la matriz de… eficiencia en la tapa cuando la carga individual de una acción mayor que la eficiencia de la acción
    • Hay un trade-off entre el rendimiento y el almacenamiento, el rendimiento inteligente, eficiente, tenga en cuenta que no vamos a iterar sobre ellos en todo.
    • Independientemente, la creación de la matriz va a tomar tiempo, tiempo que el OP ya está presionado por el. Tal vez me misspoke, el OP está preocupado por el tiempo, y cada una de las acciones innecesarias, es perjudicial para el OP, si usted mira mi respuesta, un poco de tipo de fundición rápidamente resuelto el problema de la permitida respuestas sin ir overboards
  5. 1

    Esta solución le permite introducir cualquier valor entero, incluso, negativa. Es el mismo código, con algunas modificaciones y se ha añadido un paralelo de la matriz de comparaciones. También ha eliminado algunas líneas de código que no son necesarios.

    public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    System.out.print("How many numbers are you going to enter? ");
    int num = scan.nextInt();
    int[] arr = new int[num]; //initialize array with user inputted length
    int[] arrflag = new int[num];
    for (int i = 0; i < arr.length; i++) { //enter numbers into array
    System.out.print("Enter number: ");
    arr[i] = scan.nextInt();
    arrflag[i] = 0;
    }
    int[] unique = new int[arr.length];    //initialize new array that will hold unique values
    int n=0;
    for (int i = 0; i < arr.length; i++) {            
    if (arrflag[i] == 0) {
    unique[n++] = arr[i];
    for (int j = i+1; j < arr.length; j++) {    //check all elements above int i
    if (arr[i] == arr[j]) {                        
    arrflag[j]=-1;
    }
    }                
    }
    }   
    for (int i = 0; i < n; i++) {
    System.out.println(unique[i]);
    }
    }
  6. 0

    Crear un paralelo matriz de caracteres con todos los valores como ‘.’ Cuando usted encuentra un duplicado, establezca el valor a ‘,’ en la matriz de caracteres. A continuación, en Imprimir sólo los valores de la matriz que tiene un correspondiente». » en la matriz de caracteres.

     }
    System.out.println();
    for (int i = 0; i < arr.length; i++) {
    if(a[i]=='.')
    System.out.println(arr[i]);
    }
    }

    }

  7. 0

    Ejemplo con String [].

    public static List<String> arrListWithNoDups(String arr[]){
    Map<String, Integer>map = new HashMap<String, Integer>();
    List<String>list = new ArrayList<String>();
    for(int i = 0; i<arr.length; i++){
    if(map.get(arr[i]) == null){
    map.put(arr[i], 0);
    }
    else{
    map.put(arr[i], map.get(arr[i])+1);
    }
    }
    for(int j = 0; j<arr.length; j++){
    if(map.get(arr[j])==0){
    list.add(arr[j]);
    }
    }
    return list;
    }
  8. 0

    clase pública RemoveDuplicateFromArray {

    public static void main(String[] args) {
    int[] myArray = {1, 2, 1, 4, 1, 5, 2, 5};
    System.out.println("Before removing duplicate" + Arrays.toString(myArray));
    RemoveDuplicateFromArray rd = new RemoveDuplicateFromArray();
    int[] newArray = rd.findDuplicate(myArray);
    System.out.println("Before removing duplicate" + Arrays.toString(newArray));
    }
    public int[] findDuplicate(int[] inputArray) {
    Arrays.sort(inputArray);
    int count = 0;
    for (int i = 0; i < inputArray.length; i++) {
    if (i + 1 < inputArray.length && inputArray[i] == inputArray[i + 1]) {
    count++;
    }
    }
    int[] result = new int[inputArray.length - count];
    int c = 0;
    for (int j = 0; j < inputArray.length; j++) {
    if (j + 1 < inputArray.length && inputArray[j] == inputArray[j + 1]) {
    } else {
    result[c] = inputArray[j];
    c++;
    }
    }
    inputArray = result;
    return inputArray;
    }

    }

  9. 0

    He tratado de mejorar este código, por favor, comentarios/sugerir si la mejora que se puede hacer.

    public static int[] removeDuplicate(int[] arr) {
    int[] noDuplicates = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
    boolean b = true;
    for (int j = i + 1; j < arr.length; j++) {
    if (arr[i] == arr[j]){
    b = false;
    }
    }
    if (b) {
    noDuplicates[i] = arr[i];
    System.out.print(noDuplicates[i] + " ");
    }
    }
    return noDuplicates;

    }

  10. -2
    void myFunction(int arr[])
    {
    int size=arr.length;
    for(int i=0;i<size;i++)
    {
    for(int j=i+1;j<size;j++)
    {
    if(arr[i]==arr[j])
    {
    arr[j]=arr[size-1];
    size--;
    }
    }
    }
    for(int a=0;a<size;a++)
    {
    System.out.print(arr[a]+" ");
    }
    }
    • Aunque el código es apreciado, que siempre debe de tener una explicación que acompaña. Esto no tiene que ser largo, pero se espera.
    • Mientras que el código parece que para lograr lo que el título de la pregunta, no se relacionan con el código proporcionado en la pregunta. Además, sus respuestas siempre debe ir acompañada de una explicación para hacer la lectura más fácil para personas que no están familiarizadas con el tema.

Dejar respuesta

Please enter your comment!
Please enter your name here