Question

我一直在尝试将Knuth的算法应用到我的Mastermind版本中，并且我在算法的第6步有点卡住了。 Here is a link to the steps I'm using.（向下滚动一下）

这里是从链接中复制的第6步：

6应用minimax技术查找下一个猜测，如下所示：对于每个可能的猜测，就是1296的任何未使用的代码，而不仅仅是那些代码 S，计算S中消除S的可能性可能的彩色/白色钉子得分。猜测的分数是最小的它可能从S中消除的可能性的数量猜测最高分，选择一个作为下一个猜测，选择尽可能的S成员。（Knuth遵循惯例选择具有最小数值的猜测，例如2345更低 Knuth还给出了一个例子，显示在某些情况下没有 S的成员将是最高得分的猜测之一，因此是猜不能在下一回合获胜，但有必要保证一个五胜。）

无论如何，每当我尝试执行第6步时，我的代码中的某个地方似乎都会出现问题。可能组合的数组越来越小（在它关闭的第9个转弯处上升到8），但它没有接近它应该的效率，因为这个算法应该在5转之后正确地猜测代码。我一直在环顾四周并检查Stackoverflow上的其他Knuth算法问题，但我找不到我的答案，所以我希望我可以得到一些更直接的帮助。我基本上想知道的是哪里我的代码出现故障，为什么，以及如何修复它。任何答案都将非常感谢！

这是我用来生成计算机猜测的下一个（或第一个）代码的代码。

在此代码中，possibleCombList作为我的“S”版本，如步骤中所述，code用作我当前/下一个猜测。

public void generateCode() {

    ArrayList<String> bestGuesses = new ArrayList<String>(); // Create new
                                                                // array in
                                                                // which I
                                                                // store all
                                                                // the best
                                                                // guesses.

    if (totalGuesses == 0) { // If this is the first guess, pick spot 1122
                                // from the array of combinations as my next
                                // code.
        code = possibleCombList.get(1122);
    }

    else if (possibleCombList.size() == 1) { // If there's only one
                                                // combination left in the
                                                // array, pick that one.
        code = possibleCombList.get(0);
    }

    else { // If none of the above are true, do this;
        int tempBlackPins = 0;
        int tempWhitePins = 0;

        possibleCombList.remove(possibleCombList.indexOf(code)); // Remove
                                                                    // last
                                                                    // guess.

        for (int i = 0; i < possibleCombList.size(); i++) { // (Step 5)
                                                            // Delete any
                                                            // code that
                                                            // would not
                                                            // give the same
                                                            // response if
                                                            // the last
                                                            // guess were
                                                            // the code.
            for (int a = 0; a < 4; a++) {
                if (possibleCombList.get(i).charAt(a) == (code.charAt(a))) {
                    tempBlackPins++;
                } else if (possibleCombList.get(i).contains("" + code.charAt(a))) {
                    tempWhitePins++;
                }
            }
            if (tempBlackPins != blackPins && tempWhitePins != whitePins) {
                possibleCombList.remove(i);
            }
        }

        int maxMinimum = 0;

        for (int j = 0; j < possibleCombList.size(); j++) { // (Step 6)
                                                            // Apply minMax
                                                            // technique
                                                            // (calculate
                                                            // which codes
                                                            // would
                                                            // eliminate the
                                                            // most
                                                            // possibilities
                                                            // next turn and
                                                            // pick one of
                                                            // those codes).
            int minimum = Integer.MAX_VALUE;
            tempBlackPins = 0;
            tempWhitePins = 0;
            for (int i = 0; i < possibleCombList.size(); i++) {
                for (int a = 0; a < 4; a++) {
                    if (possibleCombList.get(i).charAt(a) == (code.charAt(a))) {
                        tempBlackPins++;
                    } else if (possibleCombList.get(i).contains("" + code.charAt(a))) {
                        tempWhitePins++;
                    }
                }
                if (tempBlackPins != blackPins && tempWhitePins != whitePins) {
                    minimum++;
                }
            }

            if (minimum == maxMinimum && minimum > 0) {
                bestGuesses.add(possibleCombList.get(j));
            }

            if (minimum > maxMinimum) {
                maxMinimum = minimum;
                bestGuesses.clear();
                bestGuesses.add(possibleCombList.get(j));
            }
        }

        System.out.println(bestGuesses.size());
        code = bestGuesses.get(0); // Grab position 0 of the array with best
                                    // guesses and make that the next guess.

    }

}

谢谢你们帮助我！

Answer 1

你纠正猜测的方式有问题。

考虑这种情况：代码：（Red -x-x -x）

猜猜：（x - 红 - 红 - x）

在您的评估中，您将获得两个白色针脚，而它应该只有一个。

尝试将Knuth的Mastermind算法应用于Java中的Mastermind项目

1 个答案: