从一个字符串数组中生成所有可能的组合，不重复。

Question

我想将字符串数组中的每个元素与除其本身以外的其他元素进行比较，结果将是一个用这个字符分隔的字符串。-->结果的第2部分是元素，第1部分是1个或多个字符串，以 ,

例如 vect[a1,a2,a3]输出。

a2-->a1
a3-->a1
a2,a3 -->a1

a1-->a2
a3-->a2
a1,a3 -->a2

a1-->a3
a2-->a3
a1,a2-->a3

我试试这段代码

    public static void main(String[] args) {

        String vect[] = { "a1", "a2", "a3" };
        int n = 3;
        String attribut;

        int i = 0, j = 0, k = 0;
        for (i = 0; i < n; i++) {
            attribut = vect[i];
            for (j = 0; j < n; j++) {
                if (!attribut.equals(vect[j])) {
                    System.out.println(vect[j] + "-->" + attribut);

                }
            }
            for (j = 0; j < n; j++) {

                for (k = j + 1; k < n; k++) {
                    if ((!attribut.equals(vect[j])) && (!attribut.equals(vect[k]))) {
                        System.out.println(vect[j] + "," + vect[k] + "-->" + attribut);

                    }
                }

            }
        }
    }

代码返回结果，但我不知道如何做，当我有一个数组，例如5个字符串的字符，例如vect[a1,a2,a3,a4]out put。

a2-->a1
a3-->a1
a4-->a1
a2,a3 -->a1
a2,a4 -->a1
a3,a4-->a1
a2,a3,a4 -->a1
....

在这种情况下，-->前的逗号数量增加到4。

Answer 1

使用位操作，我们可以很容易地从一个字符串数组中迭代出所有的字符串组合。

例如，如果我们有3个字符串("a1", "a2", "a3")，我们将从1到7(2³-1)进行迭代。在这些数字的二进制表示中，从右边开始的每一个位，都指定了该输入字符串是否包含在结果中。

001    "a1"
010    "a2"
011    "a1", "a2"
100    "a3"
101    "a1", "a3"
110    "a2", "a3"
111    "a1", "a2", "a3"

现在我们修改这个逻辑，以拉出字符串值，在右边的 -->. 我们称之为 结果 值。

例如，如果我们当前生成的结果为 "a2" (结果索引1)，我们把它从位池中 "拉 "出来，所以我们现在只有2个位。在结果索引上或之后的任何位都代表比位索引高一个值索引。

这意味着位0是价值索引0，但位1是价值索引2。

01    "a1"
10    "a3"
11    "a1", "a3"

我们现在可以这样写代码来做。

static void printCombinations(String... values) {
    if (values.length < 2 || values.length > 30)
        throw new IllegalArgumentException("There must be between 2 and 30 values (got " + values.length + ")");
    if (values.length != new HashSet<>(Arrays.asList(values)).size())
        throw new IllegalArgumentException("Duplicate values not allowed");

    final int maxBit = values.length - 1;
    final int maxMask = 1 << maxBit;
    StringBuilder buf = new StringBuilder();
    for (int resIdx = 0; resIdx < values.length; resIdx++) {
        for (int bitMask = 1; bitMask < maxMask; bitMask++) {
            buf.setLength(0);
            for (int bitIdx = 0; bitIdx < maxBit; bitIdx++)
                if ((bitMask & (1 << bitIdx)) != 0)
                    buf.append(',').append(values[bitIdx >= resIdx ? bitIdx + 1 : bitIdx]);
            System.out.println(buf.append("-->").append(values[resIdx]).substring(1));
        }
    }
}

测试

printCombinations("a1", "a2", "a3", "a4");

产量

a2-->a1
a3-->a1
a2,a3-->a1
a4-->a1
a2,a4-->a1
a3,a4-->a1
a2,a3,a4-->a1
a1-->a2
a3-->a2
a1,a3-->a2
a4-->a2
a1,a4-->a2
a3,a4-->a2
a1,a3,a4-->a2
a1-->a3
a2-->a3
a1,a2-->a3
a4-->a3
a1,a4-->a3
a2,a4-->a3
a1,a2,a4-->a3
a1-->a4
a2-->a4
a1,a2-->a4
a3-->a4
a1,a3-->a4
a2,a3-->a4
a1,a2,a3-->a4