Java 获取大小为n但仅为k 1s的所有二进制组合

所以我试图生成所有大小为n的二进制文件，但条件是只有k1s。i、 e

对于尺寸n=4，k=2，（4个组合中有2个）

---

我被卡住了，不知道如何生成它。

一种方法是从

n

数字0..

n-1

集合中生成

k

值的所有组合，并使用这些值设置输出中的相应位

---

说明如何从

n

生成

k

元素的所有组合。有了这些组合，使用按位或of

1使用基本递归方法打印所有二进制序列剩下的就是强制执行约束：

    private static void binSeq(int n, int k, String seq) {
    if (n == 0) {
        System.out.println(seq);
        return;
    }

    if (n > k) {
        binSeq(n - 1, k, seq + "0");
    }

    if (k > 0) {
        binSeq(n - 1, k - 1, seq + "1");
    }
}

这是我对这个算法的非递归理解。由于二进制字符串有
2^n
排列，我们可以使用for循环迭代每个可能的字符串，并检查“1”的数量是否不等于
k
：

private static void generate(int n, int k) {
    for (int i = 0; i < Math.pow(2, n); i++) {
        if (Integer.bitCount(i) != k) {
            continue;
        }

        String binary = Integer.toBinaryString(i);

        if (binary.length() < n) {
            System.out.format("%0" + (n - binary.length()) + "d%s\n", 0, binary);
        } else {
            System.out.println(binary);
        }
    }
}

私有静态无效生成（int n，int k）{
for（int i=0；i
int n=4，k=2

    for (int i = 0; i < Math.pow(2,n) ; i++) {
        int a = Integer.bitCount(i);
        if (a == k) System.out.println(Integer.toBinaryString(i));
    }

for（inti=0；i

我认为这是最简单的答案。
下面是使用递归作为java方法的解决方案

public class NumberOfBinaryPatternsSpecificOnes {

    static int[] bitArray = new int[]{0,1}; // kept binary bits in array

    public static void main(String args[])
    {   
        System.out.println("Below are the patterns\n");
        int n = 4;
        int k = 2;
        drawBinaryPattern(n,"",k,0);
    }
    private static void drawBinaryPattern(int n,String seed,int numberOfOnes,int currentCount)
    {
        if(n==0)
        {
            if(currentCount==numberOfOnes){
                System.out.println(seed);
            }
            return;
        }   
        for(int j=0;j<bitArray.length;j++)
        {
            String temp = seed+bitArray[j];
            int currentcountTemp = bitArray[j]==1?(currentCount+1):(currentCount);

            if(currentcountTemp>numberOfOnes)
            {
                return;
            }
            drawBinaryPattern(n-1,temp,numberOfOnes,currentcountTemp);
        }
    }
}

公共类NumberOfBinaryPatterns规范{
静态int[]位数组=新int[]{0,1}；//在数组中保留二进制位
公共静态void main（字符串参数[]）
{   
System.out.println（“以下是模式\n”）；
int n=4；
int k=2；
drawBinaryPattern（n，“，k，0）；
}
私有静态void drawBinaryPattern（int n，字符串种子，int numberOfOnes，int currentCount）
{
如果（n==0）
{
if（currentCount==numberofone）{
System.out.println（种子）；
}
返回；
}   
对于（int j=0；jnumberofone）
{
返回；
}
drawBinaryPattern（n-1，temp，numberofone，currentcountTemp）；
}
}
}
您至少应该能够想出一个基本的暴力方法Knuth中实际上有一个很好的迭代方法，但我没有时间在这里实现它。从设置的最低
k
位开始，然后考虑如何找到下一个数字。在每次迭代中，在至少一个1之后找到最低的0位。将最低的0位设置为0，然后如果您已计算了
m
1s，则将最低的
m-1
位设置为1。
public class NumberOfBinaryPatternsSpecificOnes {

    static int[] bitArray = new int[]{0,1}; // kept binary bits in array

    public static void main(String args[])
    {   
        System.out.println("Below are the patterns\n");
        int n = 4;
        int k = 2;
        drawBinaryPattern(n,"",k,0);
    }
    private static void drawBinaryPattern(int n,String seed,int numberOfOnes,int currentCount)
    {
        if(n==0)
        {
            if(currentCount==numberOfOnes){
                System.out.println(seed);
            }
            return;
        }   
        for(int j=0;j<bitArray.length;j++)
        {
            String temp = seed+bitArray[j];
            int currentcountTemp = bitArray[j]==1?(currentCount+1):(currentCount);

            if(currentcountTemp>numberOfOnes)
            {
                return;
            }
            drawBinaryPattern(n-1,temp,numberOfOnes,currentcountTemp);
        }
    }
}