Выбор неповторяющихся случайных элементов из массива

#java #массивы

Создаем массив чисел от 1 до 75, с помощью рандома чисел от 1 до 75 начинаем поиск
элемента в массиве. Совпал - удалили. Ищем дальше. Совпал - удалили. Не нашли элемент
- ищем снова пока не найдем.

Вот что вышло:

int[]array;
int num = (int)(Math.random()*75+1);//имитируем выпадение числа от 1 до 75
public int[] initArray(){//создаем, инициализируем и заполняем массив цифрами от
1 до 75 включительно
    this.array = new int[75];
    for (int i = 0; i < array.length; i++){
        array[i] = i+1;
    }
    return array;
}
public static int findNumberInMass(int[] array, int num) {
    for (int i = 0; i < array.length; i++) {
        if (num == array[i]) {
            return i + 1;
        }
    }
    return 0;//вот тут он должен не найти нужный элемент и перезапустить поиск
}


Прошу помощи, а то голова кипит.
Как сделать так, чтоб он находил элемент выпавший в рандоме, искал его в массиве
и удалял?
И чтоб он искал совпадения, а если не нашел то перезапускал рандом? 
    

Ответы

Ответ 1

Если я правильно понял задачу, то приведённый ниже код иллюстрирует её решение.

class Main {
    private final static int[] numbers = initArray();

    // Заполнение массива numbers числами от 1 по 75.
    private static int[] initArray() {
        final int[] array = new int[75];
        for (int i = 0; i < array.length; ++i)
            array[i] = i + 1;
        return array;
    }

    // Поиск позиции числа n в массиве numbers. Возвращает -1, если число не найдено.
    private static int findNumber(final int n) {
        for (int i = 0; i < numbers.length; ++i)
            if (numbers[i] == n)
                return i;
        return -1;
    }

    // Получение следующего случайного числа.
    private static int nextRandom() {
        while (true) {                                // В бесконечном цикле...
            final int n = (int)(Math.random()*75+1);  // ... берём случайное число, ...
            final int pos = findNumber(n);            // ... и ищем его в массиве
numbers.
            if (pos >= 0) {           // Если число найдено, ...
                numbers[pos] = -1;    // ... то "удаляем" его...
                return n;             // ... и завершаем цикл, ...
            }
        }                             // ... иначе возвращаемся к началу.
    }

    public static void main(final String[] args) {
        for (int ignored : numbers)
            System.out.println(nextRandom());
    }
}


Здесь применена небольшая хитрость. Во-первых, если мы не нашли число в массиве,
то возвращаем заведомо невалидный индекс (-1). А во-вторых, поскольку удаление элемента
массива выполнить без создания нового массива невозможно, то во избежание этой "дорогостоящей"
операции мы просто помещаем в массив на место этого числа опять-таки заведомо невалидное
значение (-1).


Ответ 2

Более простое решение, есть класс(барабан), в котором при создании появляется N шаров,
из которого мы можем достать случайный шар из оставшихся, с помощью getNext.  

import java.util.LinkedList;

public class Game
{
  private LinkedList drum;
  public Game(int N) {
    drum = new LinkedList();
    for (int i = 0; i < N; i++) {
      drum.add(i+1);
    }
  }
  public int getNext() {
    if (drum.size() == 0) throw new java.lang.IndexOutOfBoundsException("No items more");
    final int i = (int)Math.floor(Math.random()*(drum.size()-1));
    return drum.remove(i);
  }
}

public class HelloWorld
{
  public static void main(String[] args)
  {
    System.out.println("6 of 36 game");
    int N = 36;
    Game game = new Game(N);
    for (int i = 0; i < 6; i++) {
      int selected = game.getNext();
      System.out.println("Item "+selected+ " was selected!");
    }
  }
}


Ответ 3

Вариант решения с использованием ArrayList:

    public static void main(String[] args) {

    ArrayList list = new ArrayList<>(); // создание динамического массива
    Random r = new Random();
    for (int x = 0; x < 75; x++) {
        list.add(r.nextInt(76)); // заполнение массива случайными цифрами до 75
    }
    System.out.println("Initial list = " + list); // вывод заполненного массива в консоль

    while (list.size() > 0) { // выполняем цикл пока размер массива не уменьшиться до 0 
        for (int x = 0; x < list.size(); x++) {
            int num = r.nextInt(76); // выбираем случайное число для поиска в массиве
            if (list.get(x) == num) { // сопоставляем случайное число с элементами
массива
                list.remove(x); // удаляем элемент в случае совпадения
                System.out.println(num + " was deleted");
                System.out.println(list); // выводим оставшийся массив
            }
        }
    }
    System.out.println("Array is empty"); // по исчерпанию элементов массива
}


Ответ 4

Просто и без лишних заморочек:

public static void main(String[] args) {
    //Исходное значение макс. числа
    int length = 75;
    //Булевый массив, где помечается, какое из чисел использовалось.
    //По-умолчанию каждый элемент инициализируется как false
    boolean[] arr = new boolean[length];
    //Просто для наглядности общего кол-ва попыток найти число.
    int totalIterations = 0;
    //Всего должно будет вывестись 75 чисел,
    //поэтому ставим данное условие в цикле, но итерацией будем заниматься внутри
    for (int i = 0;i