生成所有可能的二进制组合

Question

我正在尝试为两个字节 ex 生成所有可能的二进制组合。

00000000 00000001
00000000 00000010
00000000 00000011

~~我正在处理 class，但显然它根本不起作用。我无法获得 return 生成输出的方法。~~

我得到下面的代码可以正常工作，但只计算 1 个字节。我将如何更改它以计算 2 个字节的所有可能结果？

package referenceCode;

public class BinaryGenerator {

private int val = 0;
private int[] values = new int[]{0,1};





//This method converts the Binary Pattern output into a char[] so that it can be printed out to a file
public int[] binaryPatternToString() {
    int numBits = 8;
    values[0] = 0;
    values[1] = 1;
    int[] returned = null;

    for (int i = 1; i < numBits; i++) {
        returned = binaryGenerator(i);
        for (int j = 1; j < numBits; j++) {
        }
    }
    return returned;
}

private int[] binaryGenerator(int iVal) {
        int[] moreValues = new int[values.length * 2];
        int start = (int)Math.pow(2, iVal);
        for (int j = 0; j < values.length; j++) {
            moreValues[j * 2] = values[j] << 1;
            moreValues[j * 2 + 1] = values[j] << 1 | 1;
        }
        values = moreValues;

    for (int value : values) {
            System.out.println(Integer.toBinaryString(value));
    }
    return moreValues;
}}

使它成为递归方法而不是带有 for 循环的方法会更好或更有效吗？

Answer 1

我冒昧地编写了自己的版本，以便您可以看到生成这些数字的更简单方法。

这里最难的部分是递增布尔值列表。一般来说，这就像加 1。您增加 one 的位置，如果它已经是 1，则移至 10s 位置，依此类推。否则，您只需遍历所有可能性，打印出每一个。

import java.util.ArrayList;
import java.util.List;

public class Sandbox {

    // list of booleans to represent each bit
    private static List<Boolean> bytes = new ArrayList<>();

    public static void main(String[] args) {
        // initialize the list to all false
        for(int i = 0; i < 16; i++) {
            bytes.add(false);
        }

        // calculate the number of permutations
        int numPermutations = (int)Math.pow(2, 16);

        // print the first permutation
        print();

        // loop through all permutations
        for(int i = 0; i < numPermutations; i++) {
            // increment the 2 bytes
            increment();

            // print the current permutation
            print();
        }
    }

    /**
     * Prints out the current permutation
     */
    private static void print() {
        // loop through the bytes
        for(Boolean bool : bytes) {
            // print 1 or 0
            if(bool)
                System.out.print(1);
            else
                System.out.print(0);

        }

        // end the line
        System.out.println();
    }

    /**
     * Increment the bytes
     */
    private static void increment() {
        // set increment position to the end of the list
        int position = bytes.size() - 1;

        // loop through changing next digit if necessary, stopping
        // if the front of the list is reached.
        do {
            bytes.set(position, !bytes.get(position));
        } while(!bytes.get(position--) && position >= 0);
    }
}

Answer 2

如您所知，所有 java 整数都基于二进制数。因此，对于 2 个字节，最大数为 2^16 = 65536。只需遍历所有数字并获取它们的二进制值，必要时将它们补零，最后将它们存储在列表中。这将 return 所有可能的 2 字节二进制数。如需更多字节，只需增加字节变量即可。

实施：

int bytes = 2;
int nBits = bytes * 8;
int maxNumber = 1 << nBits; //this equals 2^nBits or in java: Math.pow(2,nbits)
ArrayList<String> binaries = new ArrayList<>();
for (int i = 0; i < maxNumber; i++) {
    String binary = Integer.toBinaryString(i);
    while (binary.length() != nBits) {
        binary = "0" + binary;
    }
    binaries.add(binary);
}
System.out.println(binaries);

为清楚起见，包含了 bytes 和 nBits 变量。

你也可以使用递归的方法。从一个空字符串开始，递归地在字符串的开头添加 0 或 1，然后继续，直到达到所需的位数：

public static ArrayList<String> getBinaries(int bits, String current) {
    ArrayList<String> binaries = new ArrayList<>();

    if (current.length() == bits) {
        binaries.add(current);
        return binaries;
    }

    //pad a 0 and 1 in front of current;
    binaries.addAll(getBinaries(bits, "0" + current));
    binaries.addAll(getBinaries(bits, "1" + current));

    return binaries;
}

您可以通过以下方式调用此函数：getBinaries(16,"") 2 个字节。

生成所有可能的二进制组合

Generating all possible binary combinations

java

eclipse

methods

binary

for-loop