How to generate a list of distinct random numbers including a specific number in JAVA?

Question

Ok, so the scenario is, I want to generate a list of 4 distinct random numbers which will represent 4 random choices for a quiz application. One of the 4 random choices will be the correct answer, so we will already know the index of the correct choice. This correct index or number must be included in the random number list.

For example: Consider that we have an array of length 100, containing string values representing 100 choices for a question, and the index of correct choice is 45. Now we want 4 random choices for this question including the index 45, so that the index list will be something like {2, 91, 45, 17}. Also the list shouldn't contain duplicate numbers.

Any idea how to achieve this in Java ?

Answer 1

For Java 6 and newer:

final int maxNumber = 100;
final int numbersToGenerate = 4;
final int correctAnswer = 45;

Set<Integer> possibleAnswers = new HashSet<>();
Random random = new Random();

// add correct answer
possibleAnswers.add(correctAnswer);

// add as much random answers as needed, the usage of a set prevents duplicates
while(possibleAnswers.size() < numbersToGenerate) {
    possibleAnswers.add(random.nextInt(maxNumber));
}

// convert set to list and shuffle it
List<Integer> answers = new ArrayList<Integer>(possibleAnswers);
Collections.shuffle(answers, new Random(System.nanoTime()));

For Java versions below 6 you have to write your own shuffle method, because Collections.shuffle was introduced in Java 6, as far as I know.

I first suggested to use the random api of Java 8, but found an bug in my idea. If the array of generated random numbers contains the correct answer it will not work. For your understanding:

NOT WORKING!!!

final int minNumber = 1;
final int maxNumber = 100;
final int numbersToGenerate = 3;

final int[] ints = new Random().ints(minNumber, maxNumber)
.distinct().limit(numbersToGenerate).toArray();

List<Integer> possibleAnswers = asList(ints);
possibleAnswers.add(correctAnswerIndex);
Collections.shuffle(possibleAnswers, new Random(System.nanoTime()));

NOT WORKING !!!

Answer 2

This class could help you

public class RandomQuiz {

    //The number of possible answers
    private int size;
    //The number of possible indexes
    private int n;
    //The correct index
    private int correct;

    //Constructor
    public RandomQuiz(int size, int n, int correct) {
        this.size = size;
        this.n = n;
        this.correct = correct;
    }

    //Returns size number of shuffled random indexes
    public int[] getRandomIndexes() {
        //The result set
        int[] result = new int[size];
        //We start with the correct index in the first place, so random values will be entered starting from the second place
        int index = 1;
        //First thing's first
        result[0] = correct;
        Random random;
        while (index < size) {
            //We always decrease the number of seeds
            random = new Random(n - index);
            //Getting a random value
            int randomized = random.nextInt();
            //Ensuring the numbers are not duplicate
            for (int i = 0; i < index; i++) if (randomized >= result[i]) randomized++;
            result[index++] = randomized;
        }
        //Randomize where correct will be at the end:
        random = new Random(size);
        int newIndex = random.getNextInt();
        //If the new index of correct is bigger than 0
        //than swap it with the item located on newIndex
        if (newIndex > 0) {
            result[0] = result[newIndex];
            result[newIndex] = correct;
        }
        return result;
    }
}

EDIT:

In a private chat with Anton he told me that some parts are unclear, namely:

• why did I decrease the number of seeds
• why did I increase randomized in a cycle

The number of seeds is decreased since we can use any number once maximum. If the seed was 100, then after the first item was chosen, it becomes 99 and so on. To answer the second question: if 45 was chosen and then a number at least of 45 is chosen, then we need to add 1 to that number to cope with the gap left when we have chosen 45. If there were some numbers chosen and we choose a new number, then we need to add to that number the number of gaps below it, that is, the number of already chosen smaller or equal numbers to cope with all the gaps.

Note that nothing was taken personally, I would leave the kind of comments I have left here if somebody else's correct answer was down-voted as well. I am not against my answer being down-voted, but against down-voting correct answers in general.

Answer 3

I wrote a full program based on your needs. However please take a look at what I am doing. With just a little context, this is what I created:

     // initialize a random object once.
     Random random = new Random();
     // the question
     String question = "With what letter does the name start of the new president of the USA?";
     // here are some basic answers
     String[] answers = new String[] {
      "a",
      "b",
      "c",
      "d",
      "e",
      "f",
      "g",
      "h",
      "i",
      "j",
      "k"
     };
     // you already know the correct index of the array above, in this case it's d
     int index = 3;
     // this array will contain four answers, including correct one!
     String[] four = new String[4];
     // get answer index, we will place correct value in that index
     int answerIndex = random.nextInt(four.length);
     // now lets pick 4 answers!
     for (int i = 0; i < four.length; i++) {
      // we are at the answer index!
      if (i == answerIndex) {
       four[i] = answers[index];
       continue;
      }
      int randomIndex = random.nextInt(answers.length);
      for (int j = 0; j < four.length; j++) {
       // we got duplicate here!
       if (answers[randomIndex].equals(four[j])) {
        randomIndex = random.nextInt(answers.length);
        // redo this current iteration
        j = j - 1;
       }
      }
      four[i] = answers[randomIndex];
     }

Output:

e, c, d, h
g, d, d, h
d, g, e, f
d, f, b, i
g, d, a, b
c, d, g, b
h, d, e, k
e, f, d, c
k, d, e, h
i, d, e, d

It will help if you explain where you are using it for, as well as a short demonstration at what you have already coded.