Проверка дубликатов в массиве назад

Question

Это тот же самый человек, у которого были проблемы с последней проблемой массива всего один или два дня назад. У нас есть новое задание, которое просит нас найти и заменить дубликаты в массиве случайно сгенерированных чисел. Я написал код и отправил его моему учителю для обратной связи; она ответила этим решением:

Итак, возьмите первое случайное число и сохраните его в первом слоте (это можно сделать до цикла). Затем запустите цикл, который создает второе случайное число и проверяет назад, чтобы увидеть, есть ли дубликаты из уже сохраненных. Таким образом, обратные циклы, которые проверяют дубликаты и подсчитывают до 0 из текущего местоположения и заменяют дубликаты. Как только этот тест пройдет, вы перейдете к следующему элементу, создадите новое случайное число и затем протестируете его перед дублированием.

Я сделал это здесь, и это уменьшило количество случайно сгенерированных чисел, но я по-прежнему работать в паразитный дубликат:

import java.lang.Object; 
    import java.util.Random; 

public class Prog433a { 

    public static void main(String[]args) { 

     Random randslct = new Random(); 

     int[] list = new int[20]; 
     int counter = 0; 
     int index = 0; 
     int min2 = 0; 


     System.out.println("\nAfter"); 

     for (int k = 0; k < list.length - 1; k++) { 
      list [k] = randslct.nextInt(30) + 1; 
      for (int z = list.length - 1; z >= 0; z--) { 
       if (list[k] == list[z] && z!=k) { 
        while (list[k] == list[z]) { 
         list [k] = randslct.nextInt(30) + 1; 
        } 
       } 
      } 
     } 

     int min = list[0]; 
     while (counter < list.length - 1) { 
      for (int x = 0; x < list.length - 1; x++) { // scroll through the indexes. 
       if (list[x] < min) { 
        min = list[x]; 
        index = x; // keep the index of the biggest number. 
       } 
      } 
      System.out.println(list[index]); 
      min = 100 * (list[index]); 

      list[index] = 100 * (list[index]); // change the value in the original array so it won't find the same max again 
      counter++; 
     } 
    } 
} 

Система вывод:

After 
2 
5 
6 
10 
11 
12 
13 
15 
16 
17 
19 
22 
22 
24 
25 
27 
28 
29 
29 


After 
1 
2 
2 
4 
5 
7 
8 
9 
10 
13 
15 
16 
21 
24 
25 
26 
28 
29 
30 

After 
1 
2 
3 
5 
6 
7 
11 
12 
13 
14 
15 
16 
18 
21 
22 
25 
26 
27 
29 

After 
2 
3 
3 
4 
6 
10 
12 
14 
15 
16 
17 
20 
22 
23 
24 
25 
26 
27 
30 

After 
7 
8 
11 
12 
13 
14 
15 
16 
17 
17 
18 
19 
20 
21 
23 
24 
27 
29 
30 

I отправил мой выход в нижнюю часть. Поскольку это вводный класс кодирования, я бы предпочел, чтобы решение не включало Sets или любой другой подобный. Но, увы, нищие не могут быть выборами.

Есть ли что-то, что я забыл добавить?

Answer 1

Ваша проблема заключается в том, что при обнаружении дубликата вы генерируете новый номер, но вы никогда не вернетесь и убедитесь, что вновь созданный номер не является дубликатом номеров, которые вы уже проверили. Когда вы сталкиваетесь с дубликатом, вам нужно сбросить цикл проверки через какой-либо механизм.

Я исправил код для решения проблемы, но это не самое подходящее решение. Я также сделал небольшую оптимизацию, поскольку вы перебирали ненужные индексы.

import java.util.Random; 

public class Prog433a { 

    public static void main(String[] args) { 

     Random randslct = new Random(); 

     int[] list = new int[20]; 
     int counter = 0; 
     int index = 0; 
     int min2 = 0; 

     System.out.println("\nAfter"); 

     for(int k = 0; k < list.length - 1; k++) { 

      list[k] = randslct.nextInt(30) + 1; 
      boolean unique = true; 
      for(int z = k - 1; z >= 0; z--) { 
       if(list[k] == list[z]) { 
        if(list[k] == list[z]) { 
         unique = false; 
         break; 
        } 
       } 
      } 
      if(!unique) { 
       // Repeat last index 
       --k; 
      } 
     } 

     int min = list[0]; 
     while(counter < list.length - 1) { 
      for(int x = 0; x < list.length - 1; x++) { // scroll through the indexes. 
       if(list[x] < min) { 
        min = list[x]; 
        index = x; // keep the index of the biggest number. 
       } 
      } 
      System.out.println(list[index]); 
      min = 100 * (list[index]); 

      list[index] = 100 * (list[index]); // change the value in the original array so it won't find the same max again 
      counter++; 
     } 

    } 

} 

Answer 2

Ваша ошибка в том, что вы пытаетесь добавить новый номер. Вы просто проверяете, если это не то же самое, что и раньше, но не так, как если бы оно было таким же, как раньше. Вы можете сделать это следующим образом:

boolean isDuplicate(int index, int[] list){ 
    for(int i=index-1; i>=0;i--){ 
     if(int[i]==int[index]) 
      return false 
    } 
    return true; 
} 

вместо вашей внутренней части для петли теперь вы можете написать:

do{ 
    list[k] = randslct.nextInt(30) + 1; 
}while(isDuplicate(k, list)); 

Кроме того, вы должны изменить свой выход, например, дать уже записанный вывод отрицательное значение и игнорировать отрицательные значения. Если вы хотите изменить номера до, например, Теперь ваш код не будет работать.

Answer 3

Давайте рассмотрим это на примере. Учтите, что текущий список, который был сгенерирован:

list = [5, 7, 9, 3, 8, 9] 

где 9 - текущее число.

Теперь в цикле for вы перебираете из списка [6] список [0].Здесь, в Comparision, вы приходите к 2-й индекс (список [2]), где условие

list[k] == list[z] && z != k 

оказывается, чтобы быть правдой, и новое случайное число генерируется. Предположим, что здесь новое случайное число, которое вы создали, равно «8». Цикл завершается успешно, и ваш массив теперь имеет дубликат.