如何将一个数组分成3个？

Question

我有一个包含 9 个元素的数组，我想将所有可能的元素分成 3 个。

我该怎么做？

为了更好地理解，请选择 3 of 9，然后选择 3 of 6，其余的将放在最后。并且有 1680 种可能性。我想要它们。

Answer 1

这更像是一个排列问题而不是 Java 问题，但基本上你可以计算 { 0,1,2,3,4,5,6,7,8 } 的所有排列，一旦你得到排列第一个 3 作为你的第一个数组，第二个 3 作为你的第二个数组，最后 3 个作为你的第三个数组。顺便说一句，我选择了 0-8 而不是 1-9，因为数组索引从 0 开始。

例如，第一个排列是 0,1,2,3,4,5,6,7,8。我把它分成三个部分/数组，[0,1,2]，[3,4,5]，[6,7,8]。

我并不是说这是最好的方法，也不是说这段代码已经过优化，但这是一个有趣的谜题。 :)

public class Permutations
{
    private boolean[] used;
    private StringBuilder out = new StringBuilder();
    private final String in;
    private String[] originalArray = { "a", "b", "c", "d", "e", "f", "g", "h", "i" }; // this can be changed to any array, e.g. int[]

    public static void main(String[] args)
    {
        Permutations p = new Permutations("012345678");
        p.permute();
    }

    public Permutations(final String str)
    {
        in = str;
        used = new boolean[in.length()];
    }

    public void permute()
    {
        if (out.length() == in.length())
        {
            System.out.println("Permutation: " + out);
            loadArrays(out);
            return;
        }

        for (int i = 0; i < in.length(); ++i)
        {
            if (used[i])
                continue;
            out.append(in.charAt(i));
            used[i] = true;
            permute();
            used[i] = false;
            out.setLength(out.length() - 1);
        }
    }

    public void loadArrays(StringBuilder p)
    {
        String[] array1 = new String[3];
        String[] array2 = new String[3];
        String[] array3 = new String[3];
        array1[0] = originalArray[Integer.parseInt(p.substring(0, 1))];
        array1[1] = originalArray[Integer.parseInt(p.substring(1, 2))];
        array1[2] = originalArray[Integer.parseInt(p.substring(2, 3))];
        array2[0] = originalArray[Integer.parseInt(p.substring(3, 4))];
        array2[1] = originalArray[Integer.parseInt(p.substring(4, 5))];
        array2[2] = originalArray[Integer.parseInt(p.substring(5, 6))];
        array3[0] = originalArray[Integer.parseInt(p.substring(6, 7))];
        array3[1] = originalArray[Integer.parseInt(p.substring(7, 8))];
        array3[2] = originalArray[Integer.parseInt(p.substring(8, 9))];

        System.out.println(String.format("Array1: [%s,%s,%s]", array1[0], array1[1], array1[2]));
        System.out.println(String.format("Array2: [%s,%s,%s]", array2[0], array2[1], array2[2]));
        System.out.println(String.format("Array3: [%s,%s,%s]", array3[0], array3[1], array3[2]));
        System.out.println();
    }
}

顺便说一句，有 362880 个排列而不是 1680。:)

Answer 2

最幼稚的方法，但可能比删除排列的排列更有效，如下所示：

for (int a = 0; a < 9; a++) {
    for (int b = a + 1; b < 9; b++) {
        for (int c = b + 1; c < 9: c++) {
            for (int d = 0; d < 9; d++) {
                //make sure we haven't used these values
                if (d == a || d == b || d == c)
                    continue;
                for (int e = d + 1; e < 9; e++) {
                    if (e == a || e == b || e == c)
                        continue;
                    for (int f = e + 1; f < 9; f++) {
                        if (f == a || f == b || f == c)
                            continue;
                        //group the already used values
                        int used = {a, b, c, d, e, f};
                        //create the first and second triplets
                        String[] first = {originalArray[a], originalArray[b], originalArray[c]};
                        String[] second = {originalArray[d], originalArray[e], originalArray[f]};
                        int g = -1;
                        int h = -1;
                        int i = -1;
                        //find the values that haven't been used
                        for (int j = 0; j < 9; j++) {
                            boolean found = false;
                            for (int k = 0; k < used.length; k++) {
                                if (j == used[k]) {
                                    found = true;
                                    break;
                                }
                            }
                            if (!found) {
                                if (g < 0) {
                                    g = j;
                                } else if (h < 0) {
                                    h = j;
                                } else if (i < 0) {
                                    i = j;
                                }
                            }
                        }
                        //create the third triplet
                        String[] third = {originalArray[g], originalArray[h], originalArray[i]};
                    }
                }
            }
        }
    }
}