Java 如何检查布尔表达式的所有可能性？

我目前正试图找出如何检查布尔表达式的所有可能性

！b&（c||！d）

和

！（b | | | c&&d

有八种可能的赋值给布尔人

b

c

和

d

我需要找出哪种组合会导致

（！b&&（c | | | d））！=（！（b | | | c&&d）

我现在的代码是：

public static void Main(String[] args)
{
    java.util.Random randy = new java.util.Random();
    boolean expression1 = false;
    boolean expression2 = false;
    boolean[] b = {true, false};
    boolean[] c = {true, false};
    boolean[] d = {true, false};
    int B = 0;
    int C = 0;
    int D = 0;

    while(expression1 == expression2)
    {
        B = randy.nextInt(2);
        C = randy.nextInt(2);
        D = randy.nextInt(2);
        expression1 = !b[B] && (c[C] || !d[D]);
        expression2 = !(b[B] || !c[C] && d[D]);
    }

    if(expression1 != expression2)
    {
        JOptionPane.showMessageDialog(null, "b: " + b + "c: " + c + "d: " + d);
    }
}

---

然而，这似乎不起作用。因此，我的问题是，我如何计算出布尔表达式的所有可能性，然后将它们相互比较，看看它们是否彼此不相等。

只有八种可能性，因此仅列举它们并不难。有点像这样（未进行远程测试）：

静态布尔toBoolean（int n）{
如果（n==0）{返回false；}
返回true；
}
...
对于（int b_int=0；b_int来说，只有八种可能性，所以把它们全部列举出来并不太难。类似这样的情况（未进行远程测试）：

静态布尔toBoolean（int n）{
如果（n==0）{返回false；}
返回true；
}
...
对于（int b_int=0；b_int，可以使用嵌套循环检查所有可能的组合

for(int i=0;i<2;i++){
    for(int j=0;j<2;j++){
        for(int k=0;k<2;k++){
            //Check b[i] c[j] d[k] for your condition and handle accordingly
        }
    }
}

for（inti=0；i您可以使用嵌套循环检查所有可能的组合

for(int i=0;i<2;i++){
    for(int j=0;j<2;j++){
        for(int k=0;k<2;k++){
            //Check b[i] c[j] d[k] for your condition and handle accordingly
        }
    }
}

for（int i=0；i两个表达式都是相同的，因此它们将始终彼此相等。让我们对第二个表达式进行一些转换：

!(b || !c && d)   # original expression
!(b || (!c && d)) # && has precedence over ||
!b && !(!c && d)  # negate the whole expression
!b && (c || !d)   # negate the right most expression

我们刚刚得到了与第一个表达式相同的表达式，因此
（！b&&（c|||！d））！=（！（b||！c&&d））
将始终计算为false。
两个表达式都相同，因此它们将始终彼此相等。让我们对第二个表达式进行一些转换：

!(b || !c && d)   # original expression
!(b || (!c && d)) # && has precedence over ||
!b && !(!c && d)  # negate the whole expression
!b && (c || !d)   # negate the right most expression

我们刚刚得到了与第一个表达式相同的表达式，所以
（！b&&（c|||！d））！=（！（b||！c&&d））
的计算结果总是为false。
当前方法的问题是，您使用随机化来获得所有变量的组合，但这并不保证您能得到所有变量

另一个问题似乎出现在代码片段的逻辑中：如果在任意点
expression1！=expression2
您将退出while循环，并且if语句将为true，它将打印消息对话框，然后程序将退出。由于您使用的是随机数，每次都会得到相同的值，但你总是有一种可能

一种方法是创建一个包含所涉及变量的所有真值组合的真值表，并每次测试您的表达式。例如：

private static void compareExpressions() {
    final int NUMBER_OF_VARIABLES = 3;
    final int NUMBER_OF_ROWS = (int) Math.pow(2, NUMBER_OF_VARIABLES);

    boolean values[] = new boolean[NUMBER_OF_VARIABLES];
    boolean expression1, expression2;

    // Build a truth table

    for(int i = 0; i < NUMBER_OF_ROWS; i++) {
        for(int j = NUMBER_OF_VARIABLES - 1, k = 0; j >= 0; j--, k++) {
            values[k] = (i / (int) Math.pow(2, j)) % 2 == 0 ? false : true;
        }

        // Compare what you need and show results for each row in the truth table
        expression1 = !values[0] && (values[1] || !values[2]);
        expression2 = !(values[0] || !values[1] && values[2]);

        if(expression1 != expression2) {
            System.out.println("b: " + values[0] + " c: " + values[1] + " d: " + values[2]);
        }
    }   
}

private static void compareeexpressions（）{
变量的最终整数=3；
最终整数行数=（int）Math.pow（2，变量数）；
布尔值[]=新布尔值[变量的数量]；
布尔表达式1，表达式2；
//建立一个真值表
for（int i=0；i<行数；i++）{
对于（int j=变量的个数-1，k=0；j>=0；j--，k++）{
值[k]=（i/（int）Math.pow（2，j））%2==0？false:true；
}
//比较所需内容，并在真值表中显示每行的结果
表达式1=！值[0]&&（值[1]| |！值[2]）；
表达式2=！（值[0]| |！值[1]&值[2]）；
如果（表达式1！=表达式2）{
System.out.println（“b:+values[0]+”c:+values[1]+”d:+values[2]）；
}
}   
}

使用这种方法，您可以创建任意大的真值表，但由于
values[]
数组中存在“未命名”变量，或者如果您有不同的表达式，随着变量数量的增加，真值表会变得单调乏味，更容易出错

不幸的是，解决这个问题需要表达式的解析器和更好的存储变量的方法（例如，
Map
）。
当前方法的问题是，您使用随机化来获得所有变量的组合，但这并不能保证您将获得所有变量

另一个问题似乎出现在代码片段的逻辑中：如果在任意点
expression1！=expression2
您将退出while循环，并且if语句将为true，它将打印消息对话框，然后程序将退出。由于您使用的是随机数，每次都会得到相同的值，但你总是有一种可能

一种方法是创建一个包含所涉及变量的所有真值组合的真值表，并每次测试您的表达式。例如：

private static void compareExpressions() {
    final int NUMBER_OF_VARIABLES = 3;
    final int NUMBER_OF_ROWS = (int) Math.pow(2, NUMBER_OF_VARIABLES);

    boolean values[] = new boolean[NUMBER_OF_VARIABLES];
    boolean expression1, expression2;

    // Build a truth table

    for(int i = 0; i < NUMBER_OF_ROWS; i++) {
        for(int j = NUMBER_OF_VARIABLES - 1, k = 0; j >= 0; j--, k++) {
            values[k] = (i / (int) Math.pow(2, j)) % 2 == 0 ? false : true;
        }

        // Compare what you need and show results for each row in the truth table
        expression1 = !values[0] && (values[1] || !values[2]);
        expression2 = !(values[0] || !values[1] && values[2]);

        if(expression1 != expression2) {
            System.out.println("b: " + values[0] + " c: " + values[1] + " d: " + values[2]);
        }
    }   
}

private static void compareeexpressions（）{
变量的最终整数=3；
最终整数行数=（int）Math.pow（2，变量数）；
布尔值[]=新布尔值[变量的数量]；
布尔表达式1，表达式2；
//建立一个真值表
for（int i=0；i<行数；i++）{
对于（int j=变量的个数-1，k=0；j>=0；j--，k++）{
值[k]=（i/（int）Math.pow（2，j））%2==0？false:true；
}
//比较所需内容，并在真值表中显示每行的结果
表达式1=！值[0]&&（值[1]| |！值[2]）；
表达式2=！（值[0]| |！值[1]&值[2]）；
如果（表达式1！=表达式2）{
System.out.println（“b:+values[0]+”c:+values[1]+”d:+values[2]）；
}
}   
}

使用这种方法，您可以创建任意大的真值表，但由于
values[]
数组中存在“未命名”变量，或者如果您有不同的表达式，随着变量数量的增加，真值表会变得单调乏味，更容易出错

不幸的是，解决这个问题需要表达式的解析器和更好的存储变量的方法（例如，
Map
）。
听起来像布尔代数