Question

我想创建一个程序，根据用户输入的X长度打印所有的true和false排列。我所做的是首先初始化一个数组X元素并将它们全部初始化为true。然后我循环完成它们以进行不同的排列。输出是全部为true的数组，然后它只打印false，其余为true，例如

If X (length was 2)

true  true
false true
false true
false true

这是我的代码。

import hsa.Console;

public class TorF {

public static void main (String[] args) {

    Console c = new Console();

    c.print("Length: ");
    int l = c.readInt();

    boolean[] values = new boolean[l];

    for (int i = 0; i < values.length; i++) {

        values[i] = true;
    }

    int numberOfPremutations = (int) Math.pow (2, l);

    for (int j = 0 ; j < numberOfPremutations ; j++) {

        for (int i = 0 ; i < l ; i++)
            System.out.print (values [i]);

        System.out.println ("");

        values[l - 1] = false;

        for (int i = l - 1 ; i > 0 ; i--) {

            if (values [i] == false) { 
                values [i - 1] = false;
                values [i] = true;


            }
        }

    }       

}

}

Answer 1

只需使用添加来实现它，因为这就是您要重新实现的内容。然后实现一种方法，根据每个位置的位值的值将二进制数映射到true，false值。使用long将限制您长度为63（带符号数字）。如果您需要更多，请使用BigInteger（当然，留给读者的作业）。

for( long i = 0; i < permutations; i++ ) {
    printBinary( i, l );
}

public void printBinary( long number, int length ) {
    long current = 1 << length;
    while( current > 0 ) {
        System.out.print( number & current == current ? "true " : "false " );
        current >>> 1;
    }
}

Answer 2

来吧，伙计们，让我们让这个可怜的家伙休息一下。

我认为你打算写的是更像这样的东西：

for (int i = l - 1; i >= 0; i--)
    System.out.print(values[i]);

System.out.println();

for (int i = 0 ; i < l ; i++) {
    if (values[i] == false) {
        values[i] = true;
        break;
    } else {
        values[i] = false;
    }
}

通过注意到你在这里所做的事基本上只是计算，即 0,1,2,3，等，这可以更好。对于计数中的每个二进制数，该数字的每个位都会为您提供一个您寻求的真/假值：

0 ==> 000 ==> false false false
1 ==> 001 ==> false false true
2 ==> 010 ==> false true  false

Answer 3

另一种看待问题的方法（希望）能够清楚地表明你真正在做的事情是：

for (BigInteger i = BigInteger.ZERO ; ! i.testBit(length) ; i = i.add(BigInteger.ONE)) {
    for (int j = length - 1 ; j >= 0 ; j--) {
        System.out.print( Boolean.valueOf( i.testBit(j) ).toString());
    }
    System.out.println();
}

这种方法的优点是可以使用非常大的长度。

Answer 4

在某些条件下可能会失败，但这是我发现的用于打印布尔变量组合的soln。

package function;

public class PrintngAllCombinationOfTrueFalse {
    public static void printCombination(int num) {
        int permuteLen=(int) Math.pow(2,num);
        boolean b[]=new boolean[num];
        for(int i=0;i<b.length;i++)
            b[i]=true;

        for(int j=0;j<permuteLen;j++){
            for( int i=0;i<num;i++)
                System.out.print("  "+b[i]+"  ");
            System.out.println(" ");

            for(int i=num-1;i>=0;i--){
                if(b[i]==true ){
                    b[i]=false;
                    break;
                }
                else
                    b[i]=true;
            }
        }
    }
    public static void main(String g[]){
        printCombination(3);
    }
}

打印所有True和False的排列

4 个答案:

在某些条件下可能会失败，但这是我发现的用于打印布尔变量组合的soln。