创建大小为 n 的布尔数组的所有可能方式？

Posted 2023-02-24

【中文标题】创建大小为 n 的布尔数组的所有可能方式？

【英文标题】：Creating all possible ways of a boolean array of size n?

【发布时间】：2015-01-16 10:25:43

【问题描述】：

我需要能够创建一个组合的布尔数组并通过程序运行它以查看它是否有效。如果不是，那么我将其丢弃并转到下一个组合。我的问题是我不知道如何创建这个数组，因为 n 可以等于 1-1000 之间的任何地方。所以我打算使用 Integer.toBinaryString 但这将不起作用，因为当它超过 32 时它太大了。 任何帮助都会非常有用。

谢谢！

【问题讨论】：

什么是n？数组的长度？

对不起，n 是布尔数组中需要的点数

您是否考虑过使用ArrayList？例如，ArrayList 允许您添加不定数量的布尔值。它就像一个自扩展数组。

我的主要问题是我不知道如何创建所有可能的组合，例如对于尺寸 3，第一个组合是 000，然后是 001，下一个是 010 或类似的东西那种性质。

所以... n 是布尔数组中的位数，您想创建一个包含所有布尔数的数组，直到 n 位数？那正确吗？您是否考虑过使用BigInteger？

【参考方案1】：

我知道有一个 Java 标签。我只想将我从 Java 转换的快速代码添加到答案中。

    let SIZE = 4
    let max = (pow(2, SIZE) as NSDecimalNumber).intValue;
    for i in 0..<max 
        var bin = String(i, radix: 2)
        while (bin.count < SIZE)
            bin = "0" + bin
        
        var boolArray = [Bool]();
        var count = 0
        for ch in bin 
            boolArray.append(ch == "0")
            count = count + 1
        
        print(boolArray)
    

【讨论】：

不用字符串，直接生成这个：github.com/passbook/BinarySequencer

【参考方案2】：

“接受的答案”声明

经过测试，这将适用于较大的 n 值，例如 10000 等。

但这是不正确。

public static void main(String[] args) 
    final int n = 3;
    for (int i = 0; i < Math.pow(2, n); i++) 
        String bin = Integer.toBinaryString(i);
        while (bin.length() < n)
            bin = "0" + bin;
        char[] chars = bin.toCharArray();
        boolean[] boolArray = new boolean[n];
        for (int j = 0; j < chars.length; j++) 
            boolArray[j] = chars[j] == '0' ? true : false;
        
        System.out.println(Arrays.toString(boolArray));
    

当n > 31 时，它将永远循环重复前 2^31 个组合，因为i 将溢出并且永远不会到达Math.pow(2, n)。您可以使用

轻松测试

public static void main2(String[] args)
        int n = 32;
        for (int i = 0; i < Math.pow(2, n); i++)
            if (i == Integer.MIN_VALUE) 
                // i overflows
                System.out.println("i exceeded Integer.MAX_VALUE");
            
        
    

上面的代码将无限期打印i exceeded Integer.MAX_VALUE 但是，这可以使用BigInteger 或类似的循环数据结构轻松纠正。下面的代码适用于n <= Integer.MAX_VALUE

public static void main(String[] args) 
    final int n = 32;
    BigInteger bi = BigInteger.ZERO;
    BigDecimal rows = new BigDecimal(Math.pow(2, n));
    while (bi.compareTo(rows.toBigInteger()) < 0) 
        String bin = bi.toString(2);//Integer.toBinaryString(i);
        while (bin.length() < n)
            bin = "0" + bin;
        char[] chars = bin.toCharArray();
        boolean[] boolArray = new boolean[n];
        for (int j = 0; j < chars.length; j++) 
            boolArray[j] = chars[j] == '0' ? true : false;
        
        System.out.println(Arrays.toString(boolArray));
        bi = bi.add(BigInteger.ONE);
    

【讨论】：

如果有人对一些额外的性能感兴趣（就像我需要的那样），我在循环中使用它来节省大约 40% 的时间boolean[] boolArray = new boolean[n]; long mask = 1; for (int j = 0; j < n; j++) boolArray[j] = (i & mask) > 0; mask <<= 1; （哦，请注意我使用了longs 而不是 ints 或 biginteger，这意味着它适用于 n

【参考方案3】：

我在另一个 SO question 上找到了您问题的答案，我已经为您修改了它：

public class Foo 
    public static void main(String[] args) 
        final int n = 3;
        for (int i = 0; i < Math.pow(2, n); i++) 
            String bin = Integer.toBinaryString(i);
            while (bin.length() < n)
                bin = "0" + bin;
            char[] chars = bin.toCharArray();
            boolean[] boolArray = new boolean[n];
            for (int j = 0; j < chars.length; j++) 
                boolArray[j] = chars[j] == '0' ? true : false;
            
            System.out.println(Arrays.toString(boolArray));
        
    

将产生：

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

经过测试，这将适用于 n 的高值，例如 10000 等。

【讨论】：

我看到了，但这不会引起问题，因为我必须去数组中的 1000 个不同的点，所以我需要 1000 个字节的东西。

是的，我的错。当我为n 尝试更高的数字时，我实际上得到了OutOfMemoryError。在这种情况下，您只需创建 2^n 个大小为 [n] 的数组。我已经更新了我的答案。

for (int i = 0; i < Math.pow(2, n); i++) when n > 31 将永远循环，因为整数 i 将溢出 assertTrue(Integer.MAX_VALUE + 1 == Integer.MIN_VALUE) 请参阅我的答案以获得更正的实现

我非常怀疑你用 10000 对其进行了测试，这个解决方案不仅会永远循环，而且 2^10000 是一个如此大的数字，我不确定是否有任何计算机可以计算在内。 .