Question

烦恼地，这个问题很容易，但今天让我有点头疼。（为伪代码道歉）

假设我们有两个布尔数组列表，a和b，其中：

a = [true, true, false]

b = [true, false, true]

我正在尝试使用以下规则生成a和b之间所有比较组合的列表：

如果a[i] = true和b[i] = true生成的result[i] 总是，则返回true。
如果a[i] = false和b[i] = false 始终返回false。
如果a[i] != b[i]返回一个result[i]为true且一个为false的列表。

因此compare(a,b)的预期结果是（我希望...... ）：

[true, true, false],
[true, false, false],
[true, true, true],
[true, false, true]

我试图用Java做到这一点，但似乎无法正确迭代，有人能给我一些帮助吗？

编辑：

规则3的另一个简单示例：

a = [true, false]
b = [false, true]

results:

[true, false]
[false, true]
[true, true]
[false, false]

基本上这就是我的意思:)。

Answer 1

我会说递归。我不知道你的性能目标是什么，阵列有多长，但我会做如下的事情：

1，步骤：创建一个数组，其中某些元素已修复，有些元素被规则标记为不明确，如下所示：

[Boolean.True, null, null]

这意味着null在哪里应该有真正的和为假。

2，步骤：在方法搜索null的最后一次出现时，将其更改为Boolean.True并使用此数组调用相同的方法。在下一行中将其更改为Boolean.False并再次使用相同的方法。在这个新调用中，将会有一个少于null的元素，并且您会在不明确的空间中获得包含Boolean.True和Boolean.False元素的数组。

3，步骤：在此方法中还检查数组中是否没有null值，如果没有，则将其写入输出。

当然，除了Boolean和null值之外，您还可以使用其他更有意义的对象，并且您也可以以迭代方式执行此操作，但我不知道您的问题的详细信息。

希望我能提供帮助。

Answer 2

递归是解决这类组合问题的经典方法。

void resursivelyCombine(List<List<Boolean>> result, List<Boolean> current, List<Boolean> in1, List<Boolean> in2, int index) {
    if (index == in1.size()) {
        result.add(current);
    } else {
        if (in1.get(index).equals(in2.get(index))) {
           current.add(in1.get(index));
           recursivelyCombine(result, current, in1, in2, index+1);
        } else {
           List<Boolean> temp = new ArrayList<>(current);
           temp.add(Boolean.TRUE);
           recursivelyCombine(result, temp, in1, in2, index+1);

           temp = new ArrayList<>(current);
           temp.add(Boolean.FALSE);
           recursivelyCombine(result, temp, in1, in2, index+1);
        }
    }
}

类似的东西:)代码可能需要整理一下，因为我在这里未经测试输入它。

这样称呼：

 List<List<Boolean>> results = new ArrayList<>();
 recursivelyCombine(results, new ArrayList<Boolean>(), in1, in2, 0);

布尔数组的所有组合

2 个答案: