Question

我正在编写一个模块来处理骰子滚动。鉴于y侧面的x死，我正在尝试列出所有潜在的滚动组合。

这段代码假设3个die，每个都有3个标记为1,2和3的边。（我意识到我正在使用“魔术数字”，但这只是为了简化并使基本代码工作。）

        int[] set = { 1, 1, 1 };
        list = diceroll.recurse(0,0, list, set);

...

    public ArrayList<Integer> recurse(int index, int i, ArrayList<Integer> list, int[] set){
        if(index < 3){
//          System.out.print("\n(looping on "+index+")\n");
            for(int k=1;k<=3;k++){
//              System.out.print("setting i"+index+" to "+k+" ");
                set[index] = k;
                dump(set);
                recurse(index+1, i, list, set);
            }
        }
        return list;
    }

（dump（）是一种只显示list []内容的简单方法。目前不使用变量 i 。）

我正在尝试做的是将列表[index]递增1，逐步遍历列表的整个长度并逐渐递增。

这是我的“最佳尝试”代码。这是输出：

大胆的输出是我正在寻找的。我无法弄清楚如何摆脱其余的。（这假设有三个骰子，每个骰子都有3个边。使用递归，所以我可以将它扩展到任何带有y边的x骰子。）

[1] [1] [1] [1] [1] [1]

[1] [1] [1] [1] [1] [2] [1] [1] [3] [1] [2] [3]

[1] [2] [1] [1] [2] [2] [1] [2] [3] [1] [3] [3]

[1] [3] [1] [1] [3] [2] [1] [3] [3] [2] [3] [3] [2] [ 1] [3]

[2] [1] [1] [2] [1] [2] [2] [1] [3] [2] [2] [3]

[2] [2] [1] [2] [2] [2] [2] [2] [3] [2] [3] [3]

[2] [3] [1] [2] [3] [2] [2] [3] [3] [3] [3] [3] [3] [ 1] [3]

[3] [1] [1] [3] [1] [2] [3] [1] [3] [3] [2] [3]

[3] [2] [1] [3] [2] [2] [3] [2] [3] [3] [3] [3]

[3] [3] [1] [3] [3] [2] [3] [3] [3]

我为格式化道歉，我能想出最好的。

非常感谢任何帮助。（这种方法实际上源于将数据用于非常微不足道的事情，但已经变成了个人挑战。:)

编辑：如果有另一种方法来解决这个问题，我会全神贯注，但我也想解决我当前的问题并成功使用递归来获得有用的东西。

EDIT2：运行代码包括“简单修复”。小心未使用的变量和奇怪的黑客，我还没有清理它。

package code.testing;

import java.util.ArrayList;

public class CodeTesting {

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        int[] set = { 1, 1, 1 };
        list = recurse(0,0, list, set);
    }

    public static ArrayList<Integer> recurse(int index, int i, ArrayList<Integer> list, int[] set){
        if(index < 3){
//          System.out.print("\n(looping on "+index+")\n");
            for(int k=1;k<=3;k++){
//              System.out.print("setting i"+index+" to "+k+" ");
                set[index] = k;
                if (index==2){
                    dump(set);
                }
                recurse(index+1, i, list, set);
            }
        }
        return list;
    }

    static void dump(int[] arr) {
        for (int s : arr) {
            System.out.format("[%s]", s);
        }
        System.out.println();
    }
}

Answer 1

对不起，我不得不重写代码，但它与你的算法几乎相同，但有一些更正：

public class DiceRolls {
    static void recurse(int diceNumber, int[] values, final int MAX) {
        if (diceNumber == values.length) {
            System.out.println(java.util.Arrays.toString(values));
        } else {
            for (int v = 1; v <= MAX; v++) {
                values[diceNumber] = v;
                recurse(diceNumber + 1, values, MAX);
            }
        }
    }
    public static void main(String[] args) {
        recurse(0, new int[3], 4);
    }
}

这是一个标准的连音符递归生成器。如果您要将所有int[]添加到List，请务必add(values.clone())，以便它们是独立的int[]个对象。

但是额外输出是什么？

问题是你在扔完所有骰子之前过早地倾倒了。在伪代码中，这就是你正在做的事情：

if we're not done yet
    trying all possibilities for this dice
       dump result so far // premature dumping!
       recurse for next dice

对代码的简单修复就是执行以下操作：

if we're not done yet
    trying all possibilities for this dice
       recurse for next dice
else, we're done, so
    dump result // timely!

回到Java实现，修复只是将dump(set);移动到else语句的if (index < 3)个案例。

Answer 2

仅在dump()。

时致电index == 2

顺便提一下，i和list似乎未被使用。动词是“复发”。：）

Answer 3

这是一种非递归替代方案。更改两个常量以计算不同骰子和不同骰子数量的所有组合。

package utils;

public class Dice {
    private static int FACES = 3;
    private static int NUMBER_OF_DICE = 3;

    public static void main(String[] args) {
        int start = createPair(1);
        int end = createPair(FACES);
        for (int i = start; i <= end; i++) {
            String combination = Integer.toString(i, FACES+1);
            if (combination.indexOf('0') < 0)
                System.out.println(combination);
        }
    }

    private static int createPair(int number) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < NUMBER_OF_DICE; i++) {
            sb.append(number);
        }
        return Integer.parseInt(sb.toString(), FACES+1);
    }
}

递归导致额外的不需要的数据

3 个答案:

但是额外输出是什么？