Java 求和为16的整数数组的置换

我有一个基于该值返回double的方法。数组中的每个整数都在1到6之间，表示连续掷骰子

阵列可以是16个插槽大，也可以是4个插槽小，顺序很重要。我不知道如何用java编写代码来查看每一个总数至少为16的排列。上网搜索没有任何帮助

我可怜的代码如下

public double findMax() {
    int[] dice = new int[gameBoard.length];
    for(int x : dice) x = 1;
    double max = playGame(dice);
    /* 
    int pos = 0;
    for(int i = 0; i < dice.length; i++) {
        double test = playGame(dice);
        if(test > max) test = max;
    */

    //This is where I need help, to use the int[] dice for all combinations
    //playGame(dice) yields a double
}

---

有不同的方法可以做到这一点，但递归对我来说似乎是最好的寻路算法。看起来这应该是4到16个骰子的排列，总共16个或更多如果数组的长度为16，每个可能的组合将产生16个或更多的值，所以我不确定检查该长度的排列会产生什么目的

我可以使用ArrayList或字符串实现解决方案。我不想在递归函数中使用正则数组，因为它们依赖于固定大小。只需确保添加import java.util.ArrayList；不过

无论如何，这是我使用ArrayList的代码版本。注意，我还没有测试这段代码

public ArrayList<ArrayList<int>> findPermutations( int size ) {

    // To allow the function to work with sizes less than 1
    if ( size < 1 )
        return new ArrayList<ArrayList<int>>();

    ArrayList<ArrayList<int>> permutations = new ArrayList<ArrayList<int>>();

    ArrayList<ArrayList<int>> l1 = findPermutations( new ArrayList<int>(), size, 1 );
    l1.addAll( findPermutations( new ArrayList<int>(), size, 2 ) );
    l1.addAll( findPermutations( new ArrayList<int>(), size, 3 ) );
    l1.addAll( findPermutations( new ArrayList<int>(), size, 4 ) );
    l1.addAll( findPermutations( new ArrayList<int>(), size, 5 ) );
    l1.addAll( findPermutations( new ArrayList<int>(), size, 6 ) );


    for( ArrayList<int> a : l1 ) {
        if ( computeSum( a ) >= 16 ) {
            permutations.add( a );
        }
    }

    return permutations;

}

public ArrayList<ArrayList<int>> findPermutations( ArrayList<int> record, int size, int value ) {


    record.add( value );

    if ( record.size() >= size ) {
        ArrayList<ArrayList<int>> bc = new ArrayList<ArrayList<int>>();
        bc.add( record );
        return bc;
    }

    ArrayList<ArrayList<int>> permutations = findPermutations( record.clone(), size, 1 );
    permutations.addAll( findPermutations( record.clone(), size, 2 ) );
    permutations.addAll( findPermutations( record.clone(), size, 3 ) );
    permutations.addAll( findPermutations( record.clone(), size, 4 ) );
    permutations.addAll( findPermutations( record.clone(), size, 5 ) );
    permutations.addAll( findPermutations( record.clone(), size, 6 ) );

    // For variable size array checking
    if ( record.size() >= 4 ) {
        permutations.add( record );
    }


    return permutations;
}


public int computeSum( ArrayList<int> list ) {

    int total = 0;
    for( int x : list ) {
        total += x;
    }

    return total;

}

这将为您提供一个ArrayList数组

要将其转换为数组，可以使用循环

int[][] finalVersion = new int[permutations.size()][16];
for( int i = 0; i < permutations.size(); i++ ) {
    finalVersion[i] = ( int[] ) a[i].toArray();
}

这将有望将其转换回数组

同样，我还没有在代码中对此进行测试，所以要小心bug。现在我将对此进行测试，并添加另一种不使用ArrayList的计算方法

---

编辑：我对代码做了一点修改，以便允许4和大小之间的所有排列，您只需传入16即可。

这相当简单。初始化一个足够大的数组。递归地，填充数组的元素，直到您点击16存储数组或超调放弃。不要忘记每次将数组添加到结果列表时都要制作一个深度副本，否则将继续覆盖同一数组。代码：

void createPermutations(int[] prefix, int index, int sum, List<Integer[]> results) {
    if (sum == 16) {
        results.add(createNewIntegerArray(prefix, index));
    } else if (sum < 16) {
        for (int i = 1; i <= 6; i++) {
            prefix[index] = i;
            createPermutations(prefix, index+1, sum+i, results);            
        }
    }
}

Integer[] createNewIntegerArray(int[] array, int length) {
    Integer[] result = new Integer[length];
    for (int i = 0; i < length; i++) {
        result[i] = array[i];
    }
    return result;
}

你可以称之为：

createPermutations(new int[16], 0, 0, new ArrayList<Integer[]>());

---

编辑：如果我误解了您的问题，而您不关心“超出”目标值16，您应该将==更改为>=。

您可以递归地解决它：

Input: list of size n

Solve(n) = { Sum(n,16) } + Solve(n-1)

with: Solve(4) = { Sum(4,16) }

Sum(n,16) = { find n numbers that sum up to 16 }

然后我们有：

Min(n) = 4

Max(n) = 16

Di = Input-List[i]

Di = 1 or 2 or 3 or 4 or 5 or 6

Sum(n,16) = { D1, D2, .. Dn } where D1 + D2 + .. + Dn = 16

要解决Sumn，16，您可以尝试以下用Java代码编写的算法：

---

注意：上面的代码是一个伪代码

，因此本质上你需要该数组的所有组合，它可以给出16个顺序敏感的是，并且数组大小不是固定的，这使我更困惑，但正如你提到的，这是关于一个骰子。.数组怎么可以超过6个元素？也许我可以更清楚一些。每个索引是一个掷骰子，结果是一个整数存储在骰子中。因此，为了达到16，我将掷最多16个骰子，每个索引的int值为1Got it..将在一段时间内为您提供代码..注意：递归调用可以更改为for循环，以使代码更小，并允许可变大小的骰子，如十二面体，12面骰子。“我这么做是因为我太懒了。”“格罗格·马尔布拉德，因为我没有足够的代表来评论你的问题，我在这里问你。您希望函数列出大小4到16之间的所有排列，还是仅列出该范围内的固定大小？我这样问是因为我现在列出的代码只添加了固定大小的排列，但它可以很容易地更改为具有两行代码的可变大小。

Min(n) = 4

Max(n) = 16

Di = Input-List[i]

Di = 1 or 2 or 3 or 4 or 5 or 6

Sum(n,16) = { D1, D2, .. Dn } where D1 + D2 + .. + Dn = 16

PairList<ArrayList<Byte>,Integer> sum (int n, int sum, ArrayList<Byte> list)
{
    if (list.size() == 1)
        return new Pair<ArrayList<Byte>,Integer>(list, (int)list.get(0));

    PairList<ArrayList<Byte>,Integer> result
                  = new Pair<ArrayList<Byte>,Integer> ();

    for (int i=0; i<n; i++)
    {
        ArrayList<Byte> t = new ArrayList<Byte>(list);
        t.remove(i);
        PairList<ArrayList<Byte>,Integer> r = sum(n-1, sum, t);

        for (ArrayList<Byte> l : r.getFirstList())
            if (r.getSecond(l)+list.get(i) <= sum)
            {
                l.append(list.get(i));
                r.set(l, r.getSecond(l)+list.get(i));
                result.append(r);
            }
    }

    return result;
}

Map<Byte, PairList<ArrayList<Byte>,Integer>>
            solve (int min_n, int max_n, int sum, ArrayList<Byte> list)
{
    Map<Byte, PairList<ArrayList<Byte>,Integer>> solution = null;
    solution = new Map<Byte, Pair<ArrayList<Byte>,Integer>> ();

    for (int i = min_n, i <= max_n; i++)
        solution.put(i, sum(i,sum,list));

   for (int i = min_n, i <= max_n; i++)
   {
       for (int j = 0; j < solution.get(i).count(); j++)
       {
           // remove all pairs that didn't sum up to total sum

           if (solution.get(i).getSecond(j) != sum)
               solution.get(i).removePair(j);
       }
   }

    return solution;
}