如何随机组合2个数组的元素，同时确保在所有元素至少使用一次之前不要重用元素？

Question

Essentially I'm writing a program that produces random poems out of an array of nouns and an array of adjectives.

This is accomplished basically using this line

String poem = adjectives[rand.nextInt(3)]+" "+ nouns[rand.nextInt(3)];

Simple enough, but I'm supposed to make sure that it doesn't reuse the same noun or adjective for the next poems until all of them have been used at least once already. I'm not sure how to do that.

Answer 1

Convert the arrays to list, so you can use Collections.shuffle to shuffle them. Once shuffled, you can then simply iterate over them. The values will be random order, and all words will be used exactly once. When you reach the end of an array of words, sort it again, and start from the beginning.

If a poem consists of 1 adjective + 1 noun as in your example, then the program could go something like this:

List<String> adjectives = new ArrayList<>(Arrays.asList(adjectivesArr));
List<String> nouns = new ArrayList<>(Arrays.asList(nounsArr));
Collections.shuffle(adjectives);
Collections.shuffle(nouns);

int aindex = 0;
int nindex = 0;

for (int i = 0; i < 100; ++i) {
    String poem = adjectives.get(aindex++) + " " + nouns.get(nindex++);
    System.out.println(poem);

    if (aindex == adjectives.size()) {
        aindex = 0;
        Collections.shuffle(adjectives);
    }
    if (nindex == nouns.size()) {
        nindex = 0;
        Collections.shuffle(nouns);
    }
}

The program will work with other number of adjectives and nouns per poem too.

If you must use an array, you can implement your own shuffle method, for example using the Fisher-Yates shuffle algorithm:

private void shuffle(String[] strings) {
    Random random = new Random();
    for (int i = strings.length - 1; i > 0; i--) {
        int index = random.nextInt(i + 1);
        String temp = strings[i];
        strings[i] = strings[index];
        strings[index] = temp;
    }
}

And then rewrite with arrays in terms of this helper shuffle function:

shuffle(adjectives);
shuffle(nouns);

int aindex = 0;
int nindex = 0;

for (int i = 0; i < 100; ++i) {
    String poem = adjectives[aindex++] + " " + nouns[nindex++];
    System.out.println(poem);

    if (aindex == adjectives.length) {
        aindex = 0;
        shuffle(adjectives);
    }
    if (nindex == nouns.length) {
        nindex = 0;
        shuffle(nouns);
    }
}

Answer 2

What you can do is make two more arrays, filled with boolean values, that correspond to the adjective and noun arrays. You can do something like this

boolean adjectiveUsed = new boolean[adjective.length];
boolean nounUsed = new boolean[noun.length];
int adjIndex, nounIndex;

By default all of the elements are initialized to false . You can then do this

adjIndex = rand.nextInt(3);
nounIndex = rand.nextInt(3);
while (adjectiveUsed[adjIndex])
  adjIndex = rand.nextInt(3);
while (nounUsed[nounIndex]);
  nounIndex = rand.nextInt(3);

Note, once all of the elements have been used, you must reset the boolean arrays to be filled with false again otherwise the while loops will run forever.

Answer 3

There are lots of good options for this. One is to just have a list of the words in random order that get used one by one and are then refreshed when empty.

private List<String> shuffledNouns = Collections.EMPTY_LIST;

private String getNoun() {
    assert nouns.length > 0;
    if (shuffledNouns.isEmpty()) {
        shuffledNouns = new ArrayList<>(Arrays.asList(nouns));
        Collections.shuffle(wordOrder);
    }
    return shuffledNouns.remove(0);
}

Answer 4

Best way to do this is to create a shuffled queue from each array, and then just start popping off the front of the queues to build your poems. Once the queues are empty you just generate new shuffled queues and start over. Here's a good shuffling algorithm: https://en.wikipedia.org/wiki/Fisher–Yates_shuffle

Answer 5

Assuming you have the same number of noums and adjectives shuffle both arrays and then merge result. you can shuffle the arrays multiple times if you need (once you get to the end)

    shuffleArray(adjectives);
    shuffleArray(nouns);

    for(int i=0;i<3;i++) {
        String poem = adjectives[i] + " " + nouns[i];
    }

A simple method to shuffle the arrays:

static void shuffleArray( String[] data) {
    for (int i = data.length - 1; i > 0; i--) {
        int index = rnd.nextInt(i + 1);
        int aux = data[index];
        data[index] = data[i];
        data[i] = aux;
    }
}

Answer 6

This might be overkill for this specific problem but it's an interesting alternative in my opinion:

You can use a linear congruential generator (LCG) to generate the random numbers instead of using rand.nextInt(3) . An LCG gives you a pseudo-random sequence of numbers using this simple formula

nextNumber = (a * x + b) % m

Now comes the interesting part (which makes this work for your problem): The Hull-Dobell-Theorem states that if your parameters a , b and m fit the following set of rules, the generator will generate every number between 0 and m-1 exactly once before repeating.

The conditions are:

• m and the offset c are relatively prime
• a - 1 is divisible by all prime factors of m
• a - 1 is divisible by 4 if m is divisible by 4

This way you could generate your poems with exactly the same line of code as you currently have but instead just generate the array index with the LCG instead of rand.nextInt . This also means that this solution will give you the best performance , since there is no sorting, shuffling or searching involved.

Answer 7

How about keeping two lists for the adjectives and nouns? You can use Collections.shuffle() to order them randomly.

import java.util.*;

class PoemGen {
    static List<String> nouns = Arrays.asList("ball", "foobar", "dog");
    static List<String> adjectives = Arrays.asList("slippery", "undulating", "crunchy");

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
        System.out.println(String.format("\nPoem %d", i));
        generatePoem();
        }
    }

    private static void generatePoem() {
        Collections.shuffle(nouns);
        Collections.shuffle(adjectives);
        int nounIndex = nouns.size() - 1;
        int adjectiveIndex = adjectives.size() - 1;
        while (nounIndex >= 0 && adjectiveIndex >= 0) {
            final String poem = adjectives.get(adjectiveIndex--)+" "+ nouns.get(nounIndex--);
            System.out.println(poem);
        }
    }
}

Output:

Poem 0
crunchy dog
slippery ball
undulating foobar

Poem 1
undulating dog
crunchy ball
slippery foobar

Poem 2
slippery ball
crunchy dog
undulating foobar

Answer 8

Thanks for the responses everyone! This helped immeasurably. I am now officially traumatized by the sheer number of ways there are to solve even a simple problem.