Question

我正在构建一个心智游戏，很难解释，所以我举了一个例子。

我有一个单词列表（可以是无限的）：

String myList[] = {"chair", "house", "ocean", "plane", "dog", "TV", "grass", "money" etc....}

现在是棘手的部分，我需要随机构建4个对索引/单词列表（每个列表具有相同的大小），但这符合以下规则：如果我选择了一个数字，那么与这个数字匹配的单词只出现在2个列表中。

例如这是正确的：

List1:
1/chair
2/house
3/plane
4/grass

List2
1/chair
2/dog
3/plane
4/TV

List3:
1/ocean
2/house
3/money
4/TV

List4
1/ocean
2/dog
3/money
4/grass

例如：

如果我选择数字3，则列表3和列表4匹配单词＆＃39; money＆＃39;，list 1和2匹配单词＆＃39; plane＆＃39;。总是必须有2个匹配的列表（从不少，永远不会更多）。它们应该随机地从大量单词构建，因此您无法猜出在选择数字时哪个列表将匹配。

我尝试使用一个简单的简单递归算法。但我失败了。

Answer 1

我对此问题的初步处理方法是

在Universe中选择一个随机单词
将所选单词分配给两个列表
- 不同而且
- 不满
将随机单词存储在一组已关闭的单词中以防再次被选中
冲洗并重复直至所有列表都已满

Answer 2

这样的事情应该可以解决问题（您可以相应地更改提供的单词和相应的listSize）。 listSize应该可以分割单词的数量，以便填满所有列表。

public static void main(String[] args) {
    String[] words = new String[] { "chair", "house", "ocean", "plane",
            "dog", "TV", "grass", "money" };
    // valid list sizes for 8 words: 1, 2, 4, 8
    int listSize = 4;
    List<String[]> result = distributeRandomly(words, listSize);
    for (String[] resultList : result) {
        for (int index = 0; index < listSize; index++) {
            System.out.println((index + 1) + "/" + resultList[index]);
        }
        System.out.println();
    }
}

private static List<String[]> distributeRandomly(String[] words, int listSize) {
    // each word goes into 2 lists, so how many lists do we need?
    int listCount = words.length * 2 / listSize;
    if (listCount * listSize != words.length * 2) {
        throw new IllegalArgumentException("Number of words"
                + " must be a multiple of the size of the individual lists!");
    }
    // initialize result lists (here arrays) in fitting size
    List<String[]> listsToFill = new ArrayList<String[]>(listCount);
    for (int index = 0; index < listCount; index++) {
        listsToFill.add(new String[listSize]);
    }
    // be sure to randomly pick the given words by shuffling them
    List<String> shuffledWords = new ArrayList<String>(Arrays.asList(words));
    Collections.shuffle(shuffledWords);

    List<String[]> result = new ArrayList<String[]>(listCount);
    int maxWordPosition = listSize - 1;
    // distribute words
    for (String word : shuffledWords) {
        // word is supposed to be inserted in two lists at the same index
        int wordPosition = -1;
        // iterate result lists
        Iterator<String[]> listIterator = listsToFill.iterator();
        while (listIterator.hasNext()) {
            String[] list = listIterator.next();
            if (wordPosition == -1) {
                // look out for the first list with an empty slot
                for (int index = 0; index < listSize; index++) {
                    if (list[index] == null) {
                        // found empty slot at this index
                        wordPosition = index;
                        // insert word here (first list)
                        list[wordPosition] = word;
                        if (wordPosition == maxWordPosition) {
                            // the list is full, no more empty slots here
                            listIterator.remove();
                            result.add(list);
                        }
                        break;
                    }
                }
            } else if (list[wordPosition] == null) {
                // found second list with an empty slot at the same index
                list[wordPosition] = word;
                if (wordPosition == maxWordPosition) {
                    // the list is full, no more empty slots here
                    listIterator.remove();
                    result.add(list);
                }
                // we are done with this word
                break;
            }
        }
        // shuffle result lists again, to ensure randomness
        Collections.shuffle(listsToFill);
    }
    return result;
}

这会产生（例如）以下输出：

1/grass
2/TV
3/plane
4/ocean

1/grass
2/dog
3/money
4/chair

1/house
2/dog
3/money
4/ocean

1/house
2/TV
3/plane
4/chair

在不同的列表中巧妙地构建对元素

2 个答案: