这种问题可以用卡诺图来解决：

从中可以推断，第一行需要一组润滑油，第一列需要两组润滑油，从而获得多基因润滑油的最佳解决方案：

目标应该是可读性。阅读代码的人必须立即理解您的意图。这是我的解决方案。

说明：

如果a==b都是真的或都是假的。如果两者都是真的，我们就找到了两个真正的布尔值，并且可以返回真值(通过返回a)。如果两者都是错误的，即使c是正确的，也不能有两个真正的布尔值，因此我们返回错误(通过返回a)。这就是(a==b) ? a部分。那么: c呢？如果a==b是假的，那么a或b中的一个必须是真的，所以我们找到了第一个真正的布尔值，唯一重要的是，如果c也是真的，那么我们返回c作为答案。

您不需要使用运算符的短路形式。

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

这与您的版本执行相同数量的逻辑操作，但是完全没有分支。

这是一种测试驱动的通用方法。不是像目前为止提供的大多数解决方案那样"高效"，而是清晰的、经过测试的、有效的和通用的。

总结一下。它被称为布尔代数是有原因的：

如果你看这里的真值表，你会发现乘法是布尔的，简单地说加法就是异或。

要回答您的问题：

这真的取决于你所说的"改进"是什么意思：

Clearer？

Terser？

更一般？

更具伸缩性？

更快？

哪一个"改进"在很大程度上取决于形势。

下面是另一个使用map/reduce的实现。这可以很好地扩展到数十亿个布尔值？在分布式环境中。使用MUGODB：

创建布尔型数据库values：

创建地图，减少功能：

编辑：我喜欢curtaindog关于将map/reduce应用于泛型列表的回答，所以这里有一个map函数，它接受一个回调，该回调决定是否应该计算一个值。

运行图/减少：

另一个直接代码示例：

显然，这不是最简洁的代码。

补遗

另一个(稍微优化的)版本：

这可能运行得稍微快一些，假设与0的比较将使用比与2的比较更快(或更少)的代码。

在这里(到目前为止)回答：

并通过反编译器运行它们(javap-c x>results.txt)：

你能看到吗？：比原版稍好一点。最好的是避免完全分支的那个。从指令较少(在大多数情况下)的角度来看，这很好，对CPU的分支预测部分更好，因为分支预测中的错误猜测可能导致CPU停止。

我想说最有效的一个是从月亮阴影整体。它平均使用最少的指令，并减少了CPU中管道暂停的可能性。

要100%确定，您需要找出每个指令的成本(以CPU周期为单位)，但不幸的是，这些成本并不容易获得(您必须查看热点的源代码，然后查看CPU供应商对每个生成的指令所用时间的说明)。

有关代码的运行时分析，请参阅Rotsor更新的答案。

还有另一种方法，但不是很好：

Booleanhashcode值固定为1231(真)和1237(假)，因此可以使用<= 3699。

最明显的改进是：

然后

但这些改进是微不足道的。

我不喜欢三元(最上面的答案是return a ? (b || c) : (b && c);)，我想我没看到有人提到过。它是这样写的：

在克洛杰里：

用途：

我们可以将bools转换为整数并执行以下简单检查：

我想我还没有看到这个解决方案：

它的优点是一旦达到你要找的数字，它就会断开。如果这是"1000000个值中至少有2个是真的"，前两个值实际上是真的，那么它应该比一些更"正常"的解更快。

由于没有规定如何改进代码，我将努力改进代码，使其更有趣。我的解决方案是：

如果有人想知道这段代码是否有效，可以使用相同的逻辑进行简化：

}

这可以进一步归结为：

但现在不再有趣了。

C解决方案。

或者您可能更喜欢：

这么做的方法太多了…

文字解释适用于所有主要语言：

但我可能会让人们更容易阅读，并且可以扩展到三种以上——这似乎被许多程序员忘记了：

作为@tofubeer tofubeer优秀文章的补充，请考虑@pdox pdox的答案：

还可以考虑"javap-c"给出的反汇编版本：

pdox的答案编译的字节代码比以前的任何答案都少。它的执行时间与其他时间相比如何？

至少在我的电脑上，pdox的答案比@moonshadow moonshadow的答案略快，使pdox成为最快的整体(在我的HP/Intel笔记本电脑上)。

最简单的方法(IMO)不容易混淆和阅读：

通过真值表计算：

这种类型的阅读效果更好：

在C：

露比：

[a, b, c].count { |x| x } >= 2

它可以在javavm上的jruby中运行。；-)

他可能没有寻找任何复杂的东西，比如位比较运算符(通常不复杂，但是有布尔值，使用位比较运算符是非常奇怪的)，或者一些非常迂回的东西，比如转换为int并求和。

解决这一问题最直接和自然的方法是使用如下表达式：

如果你愿意的话，把它放在一个函数中，但是它并不复杂。该解决方案在逻辑上简洁高效。

应该是：

另外，如果true自动转换为1，false自动转换为0：

当我看到这个问题时，我的第一个想法是：

在看到其他帖子后，我承认

更优雅。我想知道相对的运行时间是什么。

无论如何，我认为这种解决方案比

因为品种更容易扩展。如果稍后我们添加第四个必须测试的变量呢？如果变量的数量是在运行时确定的，并且我们被传递一个未知大小的布尔数组，会怎么样？依赖于计数的解决方案比依赖于列出所有可能组合的解决方案更容易扩展。此外，当列出所有可能的组合时，我怀疑犯错误要容易得多。比如试着为"4中的任意3"编写代码，并确保您不会错过任何代码，也不会复制任何代码。现在用"任意5/7"试试。

我找到了这个解决方案。

三元操作符可以让书呆子的汁液流动，但它们可能会令人困惑(使代码不易维护，从而增加了bug注入的可能性)。杰夫·阿特伍德在这里说得很好：

It's a perfect example of trading off
an utterly meaningless one time
write-time savings against dozens of
read-time comprehension penalties-- It
Makes Me Think.

为了避免使用三元运算符，我创建了以下函数：

这和其他一些解决方案一样酷吗？不，更容易理解吗？对。这会导致可维护性更强、错误代码更少吗？对。

EDCOX1×4×-Java如何使用三个比较而不是OP的六。

错了，我应该早点检查。

对这个问题的最佳答案应该是"作为一名员工，我写它是很重要的，这样我的意思就清晰了，同时在绩效需要的地方保持效率。"下面是我写它的方式：

实际上，这个测试是如此的做作，以至于如果你用一个简单的注释来适应它，那么写一个最快、最神秘的方法是完全可以接受的。但是，总的来说，在这个一行程序的世界中，我们需要在这个世界上有更多可读的代码。-)

不是在性能上下文中，而是良好的代码(可重用的可扩展和可读代码)

在我编写Java的拙劣意见中，容易处理意外变化和重复代码比简洁(脚本语言域)或快速程序更重要。

仅供参考，这只是一个完整的加法器的执行位。在硬件方面，您可以使用逻辑工作来根据不同的布尔表达式来确定最佳电路。我想传统的XOR解决方案要比海报所展示的不那么简洁的表达更费劲。

让这三个布尔值为a、b和c…。

您可以使用k-map并使用布尔表达式…

在这种情况下，布尔表达式将是a(b+c)+c

或者如果((a&；&；(b_c))c){回归真实；}其他的返回错误；

这个问题的非简化解决方案是：

减少使用k-maps，可以得到：

我们可以通过在A'BC和ABC的造币厂使用独家或联合使用ABC和AB'C的造币厂来进一步减少这一点：

当然，这个问题更多的是关于你如何解决问题/思考，而不是你实际的编码能力。

一个稍微简洁的版本可以是

return ((a ^ b) && (b ^ c)) ^ b

但是就像以前的海报上说的，如果我在我正在研究的任何代码中看到这个，就会有人听到了。：)

所提出问题中的2和3肯定是神奇的数字。"正确"的答案取决于面试官是否试图掌握布尔逻辑(我不认为PDOX的答案在这方面是最好的)或者你对架构问题的理解。

我倾向于使用一个map-reduce解决方案，它可以接受任何具有任意条件的列表。

x=或(a+b，c)

A BC X

1 1 0 0

0 0 1 1

0 1 1 1

如果目标是为三个操作数返回三个值中的两个，则算术和迭代方法往往相对无效。在许多CPU架构中，一个好的形式是"返回((A&B)&C)(A&B)；"。这需要四个布尔运算。在单累加器机器上(在小型嵌入式系统中很常见)，每字节总有七条指令。"RETURN(A&B)(A&C)(B&C)；"形式可能看起来更好，但它需要五个布尔运算，或者一台累加器机器上每字节九个指令。

顺便说一下，在CMOS逻辑中，计算"三取二"需要12个晶体管(相比之下，一个反相器需要两个，一个两输入NAND或不需要四个，一个三输入NAND或不需要六个)。

有一件事我没有看到其他人指出，在求职面试的"请给我写一些代码"部分，一个标准的做法是说"你能改进一下吗？"或者"你对此完全满意"或者"这是尽可能优化的吗？"当你说你完成了。有可能你听到"你会怎样改进它"，因为"这可能会得到改进；如何改进？".在这种情况下，将if(x) return true; else return false;习惯用法更改为"仅return x"是一种改进，但要注意，有时他们只是想了解您对问题的反应。我听说有些面试官会坚持认为完美代码中有一个缺陷，只是为了看看你如何处理它。

在C中，从我的头顶开始：

应该很快。

呼叫如下：

这样，您就可以将规则(两个必须为true)留给调用方，而不是将它们嵌入到方法中。

现在用Java 8，我真的很喜欢这样的事情：

使用Java 8的流功能，对任意数量的任意数量的布尔值采取另一种方法。如果在处理所有元素之前流达到极限，则流会短路：

输出：

这个怎么样：

丙：

在我看来，三分之三是相当任意的数字，函数应该使用任意的数字。为了回答这个问题，我写了一个函数，如果数组中的x是真的，就可以算出这个函数。

如果我把布尔值转换成一个数，如果这个数不是二的幂，它至少有两个真值。

我只是给你一个选择。

使用三元运算符解决问题的最简单形式是：

您可能还希望通过使用需求的双重否定来投资寻找解决方案，也就是说，您需要满足条件，而不是至少两个真值，最多一个假值。

函数ko返回答案：

你可以从varargsa.k.a boolean[]中选择你想要真实的at least个数：

另一个：

我相信使用普通的布尔运算符(a b)&；&；(b c)是很好的，而且更简单。

你可以把这三个字母中的任何一个换成另外两个字母中的任何一个，它仍然是相同的表达式。

我认为最简单的解决方案是：

返回(A&B)C；

我的第一个想法是

但为了便于阅读，我喜欢你们建议的A+B+C>=2解决方案。