这个问题的非约简解是:

a'bc + abc' + abc + ab'c

减少使用k - map，可以得到:

bc + ab + ac

可以通过在a'bc和abc' minterms上使用exclusive或，并结合abc和ab'c minterms来进一步减少此值:

b(a ^ c) + ac

函数ko返回答案:

static int ho(bool a)
{
    return a ? 1 : 0;
}

static bool ko(bool a, bool b, bool c)
{
    return ho(a) + ho(b) + ho(c) >= 2 ? true : false;
}

这个问题的最佳答案应该是:“作为一名员工，我写出来的东西很重要，这样我的意思就能清楚地表达出来，同时又能保持绩效所需的效率。”我是这样写的:

function atLeastTwoAreTrue(a, b, c) {
    return (a && b) || (b && c) || (a && c);
}

在现实中，这个测试是如此的刻意，以至于如果您用一个简单的注释来容纳它，那么编写一个最快、最神秘的方法是完全可以接受的。但是，一般来说，在这个一行代码的世界里，我们需要更多可读的代码。: -)

这真的取决于你对“改进”的定义:

清晰吗?

boolean twoOrMoreAreTrue(boolean a, boolean b, boolean c)
{
    return (a && b) || (a && c) || (b && c);
}

反之亦然？

boolean moreThanTwo(boolean a, boolean b, boolean c)
{
    return a == b ? a : c;
}

更一般的?

boolean moreThanXTrue(int x, boolean[] bs)
{
    int count = 0;

    for(boolean b : bs)
    {
        count += b ? 1 : 0;

        if(count > x) return true;
    }

    return false;
}

更多的可伸缩的吗?

boolean moreThanXTrue(int x, boolean[] bs)
{
    int count = 0;

    for(int i < 0; i < bs.length; i++)
    {
        count += bs[i] ? 1 : 0;

        if(count > x) return true;

        int needed = x - count;
        int remaining = bs.length - i;

        if(needed >= remaining) return false;
    }

    return false;
}

更快呢?

// Only profiling can answer this.

哪一种是“改进”的，很大程度上取决于具体情况。

如果你有很多布尔值，操作符重载很容易。

operator fun Boolean.unaryPlus() = if (this) 1 else 0
// ...
if(+bool1 + +bool2 + ... + +boolN > 2) {
    // ...
}

我的第一个想法是

return (a||b)&&(b||c)

但为了便于阅读，我喜欢你们提出的a+b+c>=2的解决方案