为命题逻辑公式创建真值表？

Question

我想创建一个程序，根据用户给出的逻辑公式，例如 ((¬A ∧ B) ∨ C) ∧ A，计算其真值表。 在这种情况下，如果 A=1、B=0、C=1 或 A=1、B=1、C=1，则该公式为真，在任何其他情况下为假。

但是，我不知道如何创建一个可以读取给定表达式的方法，然后计算所有可能的结果。

Answer 1

我不知道如何创建一个可以读取给定表达式的方法，然后计算所有可能的结果。

好的，让我们从将任务分解为子任务开始。 这是您需要做的...

1. 将作为输入的字符串解析到程序使用的某些内部数据结构中。这是一项艰巨的任务。确保通过单元测试涵盖相关方法。
2. 计算真值表。这更容易。您只需要遍历所有可能的输入集。这些将是从 0 到 2^n-1 的二进制数，其中 n 是布尔输入的数量。

让我们看看你可以使用哪些资源......

1. 解析部分可以改写this
2. 要生成所有可能的输入，您可以使用this

另外，请确保通过单元测试覆盖您的方法。像这样复杂的逻辑很容易出错，调试需要几个小时。因此，单元测试将为您节省大量时间。

这能解决您的问题吗？在 cmets 中告诉我。

Answer 2

试试这个。

interface Bool {
    boolean get();
    default Bool and(Bool r) { return () -> get() ? r.get() : false; }
    default Bool or(Bool r) { return () -> get() ? true : r.get(); }
    default Bool not() { return () -> !get(); }
}

static class TruthTable {
    String formula;
    int index, ch;
    List<Character> variables;
    Map<Character, Boolean> map;
    Bool bool;

    int get() {
        return ch = index < formula.length() ? formula.charAt(index++) : -1;
    }

    boolean match(int expect) {
        if (ch == expect) {
            get();
            return true;
        }
        return false;
    }

    Bool element() {
        Bool b;
        if (match('(')) {
            b = expression();
            if (!match(')'))
                throw new RuntimeException("')' expected");
        } else if (Character.isAlphabetic(ch)) {
            char v = (char) ch;
            get();
            if (!variables.contains(v))
                variables.add(v);
            b = () -> map.get(v);
        } else
            throw new RuntimeException("unknown char: " + (char) ch);
        return b;
    }

    Bool factor() {
        if (match('￢'))
            return element().not();
        return element();
    }

    Bool term() {
        Bool b = factor();
        while (match('∧'))
            b = b.and(factor());
        return b;
    }

    Bool expression() {
        Bool b = term();
        while (match('∨'))
            b = b.or(term());
        return b;
    }

    String str(boolean b) {
        return b ? "T" : "F";
    }

    void print() {
        for (char v : variables)
            System.out.print(str(map.get(v)) + " ");
        System.out.println(str(bool.get()));
    }

    void test(int i) {
        if (i >= variables.size())
            print();
        else {
            char c = variables.get(i);
            map.put(c, true);
            test(i + 1);
            map.put(c, false);
            test(i + 1);
        }
    }

    public void make(String formula) {
        this.formula = formula.replaceAll("\\s", "");
        index = 0;
        variables = new ArrayList<>();
        map = new HashMap<>();
        get();
        bool = expression();
        if (ch != -1)
            throw new RuntimeException(
                "extra string '" + formula.substring(index - 1) + "'");
        for (char v : variables)
            System.out.print(v + " ");
        System.out.println(formula);
        test(0);
        System.out.println();
    }
}

和

public static void main(String[] args) {
    new TruthTable().make("￢A");
    new TruthTable().make("￢A ∧ B");
    new TruthTable().make("(￢A ∧ B) ∨ C");
    new TruthTable().make("((￢A ∧ B) ∨ C) ∧ A");
}

输出：

A ￢A
T F
F T

A B ￢A ∧ B
T T F
T F F
F T T
F F F

A B C (￢A ∧ B) ∨ C
T T T T
T T F F
T F T T
T F F F
F T T T
F T F T
F F T T
F F F F

A B C ((￢A ∧ B) ∨ C) ∧ A
T T T T
T T F F
T F T T
T F F F
F T T F
F T F F
F F T F
F F F F