blocks|key|1656341|text|很长但很简单的，(空泛的)正常形态：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1656342|+(~a+&+b+&+c+&+d)+%7C+(a+&+~b+&+c+&+d)+%7C+(a+&+b+&+~c+&+d)+%7C+(a+&+b+&+c+&+~d)|code-block|syntax|javascript|1656343|它可以简化，但这需要更多的思考：|1656344|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Long but very simple, (disjuntive) normal form:

<pre><code> (~a &amp; b &amp; c &amp; d) | (a &amp; ~b &amp; c &amp; d) | (a &amp; b &amp; ~c &amp; d) | (a &amp; b &amp; c &amp; ~d)
</code></pre>

It may be simplified but that requires more thinking :P

blocks|key|1656346|text|我能做的就是((x+%5E+y)+%5E+(a+%5E+b))+&&+((a+%7C%7C+x)+&&+(b+%7C%7C+y))|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1656347|entityMap|0|LINK|mutability|MUTABLE|url|https://www.wolframalpha.com/input/?i=%2528x%2Bxor%2By%2529%2Bxor%2B%2528a%2Bxor%2Bb%2529%2Band%2B%2528a%2Bor%2Bx%2529%2Band%2B%2528b%2Bor%2By%2529%2Btruth%2Btable^0|6|19|6|19|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

The best I can do is <a href="https://www.wolframalpha.com/input/?i=%28x+xor+y%29+xor+%28a+xor+b%29+and+%28a+or+x%29+and+%28b+or+y%29+truth+table"><code>((x ^ y) ^ (a ^ b)) &amp;&amp; ((a || x) &amp;&amp; (b || y))</code></a>

blocks|key|657498|text|不确定它是否简单，但也许。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|657499|((x+xor+y)+and+(a+and+b))+or+((x+and+y)+and+(a+xor+b))|offset|length|style|CODE|657500|entityMap|0|LINK|mutability|MUTABLE|url|https://www.wolframalpha.com/input/?i=%2528x%2Bxor%2By%2529%2Band%2B%2528a%2Band%2Bb%2529%2Bor%2B%2528x%2Band%2By%2529%2Band%2B%2528a%2Bxor%2Bb%2529%2Btruth%2Btable^0|0|0|1I|0|1I|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@$D|R|E|S|F|G]]|9|@$D|T|E|U|1|V]]|A|$]]|$1|H|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

Not sure it is simpler, but maybe. 

<a href="https://www.wolframalpha.com/input/?i=%28x+xor+y%29+and+%28a+and+b%29+or+%28x+and+y%29+and+%28a+xor+b%29+truth+table"><code>((x xor y) and (a and b)) or ((x and y) and (a xor b))</code></a>

blocks|key|657565|text|#1:使用分支?：3或4个操作|type|unstyled|depth|inlineStyleRanges|entityRanges|data|657566|A+%5E+B+?+C+&+D+:+(+C+%5E+D+)+&+A|code-block|syntax|javascript|657567|#2非分支，7次操作|657568|(A+%5E+B+%5E+C+%5E+D)+&+((A+&+B)+%7C+(C+&+D))|657569|当我用来分析所有的东西时，我发现非分支解决方案的操作速度要快得多，因为CPU可以更好地预测代码路径，同时执行更多的操作。但是，分支语句中的工作量减少了大约50%25。|offset|length|657570|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Branch_prediction^0|0|0|0|0|G|3|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

#1: Using a branching ?: 3 or 4 operations 

<pre><code>A ^ B ? C &amp; D : ( C ^ D ) &amp; A
</code></pre>

#2 Non-Branching, 7 operations

<pre><code>(A ^ B ^ C ^ D) &amp; ((A &amp; B) | (C &amp; D))
</code></pre>

Back when I use to profile everything, I found <a href="http://en.wikipedia.org/wiki/Branch_prediction">non-branching</a> solutions were quite a bit quicker operation-for-operation as the CPU could predict the code path better, and execute more operations in tandem. There is about 50% less work in the branching statement here though.

blocks|key|657593|text|这个答案取决于表示的系统，但是如果0是唯一被解释为false的值，而且not(false)总是返回相同的数值，那么not(a)+%2B+not(b)+%2B+not(c)+%2B+not(d)+=+not(0)应该能做到这一点。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|657594|entityMap^0|Z|A|1L|16|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

This answer depends on the system of representation, but if 0 is the only value interpreted as false, and <code>not(false)</code> always returns the same numeric value, then <code>not(a) + not(b) + not(c) + not(d) = not(0)</code> should do the trick.

blocks|key|1656448|text|如果你想要的是纸上(非编程)解决方案，那么K-映射和Quine算法就是你想要的，它们帮助你缩小你的布尔函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1656449|在你的例子中，结果是|1656450|y+=+(x̄3+%5E+x2+%5E+x1+%5E+x0)+∨+(x3+%5E+x̄2+%5E+x1+%5E+x0)+∨+(x3+%5E+x2+%5E+x̄1+%5E+x0)+∨+(x3+%5E+x2+%5E+x1+%5E+x̄0)|code-block|syntax|javascript|1656451|如果您想以编程的方式完成这一任务，那么通过布尔值列表进行迭代和计数"true“的次数是非常简单和简单的。|1656452|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you're after the on-the-paper (non-programming) solution, then K-maps and Quine-McCluskey algorithms are what you're after, they help you minify your boolean function.

In your case, the result is 

<pre><code>y = (x̄3 ^ x2 ^ x1 ^ x0) ∨ (x3 ^ x̄2 ^ x1 ^ x0) ∨ (x3 ^ x2 ^ x̄1 ^ x0) ∨ (x3 ^ x2 ^ x1 ^ x̄0)
</code></pre>

If you want to do this programmatically, non-fixed amount of variables and a custom "threshold", then simply iterating thru a list of boolean values and counting occurrences of "true" is pretty simple and straightforward.

blocks|key|657652|text|我建议以一种表明您的意思的方式来编写代码。如果您希望3个值为真，那么在我看来，值3出现在某个地方是很自然的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|657653|例如，在C%2B%2B中|offset|length|style|CODE|657654|if+((int)a+%2B+(int)b+%2B+(int)c+%2B+(int)d+==+3)
++++...|code-block|syntax|javascript|657655|这在C%2B%2B中得到了很好的定义：standard+(§4.7/4)表示将bool转换为int提供了预期值0或1。|657656|在Java和C#中，您可以使用以下构造：|657657|if+((a?1:0)+%2B+(b?1:0)+%2B+(c?1:0)+%2B+(d?1:0)+==+3)
++++...|657658|entityMap^0|0|4|3|0|0|2|3|F|H|Z|4|16|3|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@$D|10|E|11|F|G]|$D|12|E|13|F|G]|$D|14|E|15|F|G]|$D|16|E|17|F|G]]|9|@]|A|$]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|J|7|19|8|@]|9|@]|A|$K|L]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$]]

I suggest writing the code in a manner that indicates what you mean. If you want 3 values to be true, it seems natural to me that the value 3 appears somewhere.

For instance, in <code>C++</code>:

<pre><code>if ((int)a + (int)b + (int)c + (int)d == 3)
 ...
</code></pre>

This is well defined in <code>C++</code>: the <code>standard (§4.7/4)</code> indicates that converting <code>bool</code> to <code>int</code> gives the expected values 0 or 1.

In Java and C#, you can use the following construct:

<pre><code>if ((a?1:0) + (b?1:0) + (c?1:0) + (d?1:0) == 3)
 ...
</code></pre>

blocks|key|1656618|text|请记住，如果对于编程问题，而不仅仅是逻辑问题，答案显然取决于编程语言的选择。有些语言支持其他语言不常见的特性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1656619|例如，在C%2B%2B中，您可以使用以下方法测试您的条件：|1656620|(a+%2B+b+%2B+c+%2B+d)+==+3|code-block|syntax|javascript|1656621|这应该是在支持从布尔类型到整数类型的自动(低级别)转换的语言中进行检查的最快方法。但同样，这个问题没有一个普遍的答案。|1656622|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Keeping in mind that SO if for programming questions, rather than mere logical problems, the answer obviously depends on the choice of a programming language. Some languages support features that are uncommon to others.

For example, in C++ you could test your conditions with:

<pre><code>(a + b + c + d) == 3
</code></pre>

This should be the fastest way to do the check in languages that support automatic (low-level) conversion from boolean to integer types. But again, there is no general answer for that problem.

blocks|key|657711|text|若要从所有n中至少检查Boolean为真，(n必须小于或等于Boolean：P的总数)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|657712|if+(((a+?+1:0)+%2B+(b+?+1:0+)+%2B+(c+?+1:0)+%2B+(d+?+1:0+))+>=+n)+{
++++//+do+the+rest
}|code-block|syntax|javascript|657713|编辑：在@Cruncher的评论之后|BOLD|657714|检查4中的3+boolean|657715|if+(((a+?+1:0)+%2B+(b+?+1:0+)+%2B+(c+?+1:0)+%2B+(d+?+1:0+))+==+3)+{
++++//+do+the+rest
}|657716|另一个：|657717|((c+&+d)+&+(a+%5E+b))+%7C+((a+&+b)+&+(c+%5E+d))+(详细信息)|657718|entityMap|0|LINK|mutability|MUTABLE|url|https://www.wolframalpha.com/input/?i=%2528%2528c%2520and%2520d%2529%2520and%2520%2528a%2520xor%2520b%2529%2529%2520or%2520%2528%2528a%2520and%2520b%2529%2520and%2520%2528c%2520xor%2520d%2529%2529%2520truth%2520table|1|https://www.wolframalpha.com/input/?i=%2528%2528c%2520and%2520d%2529%2520and%2520%2528a%2520xor%2520b%2529%2529%2520or%2520%2528%2528a%2520and%2520b%2529%2520and%2520%2528c%2520xor%2520d%2529%2529^0|5|1|B|7|U|7|0|0|0|2|0|7|7|0|0|0|0|15|0|15|0|17|4|1|0^^$0|@$1|2|3|4|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1D|8|@$9|1E|A|1F|B|M]]|D|@]|E|$]]|$1|N|3|O|5|6|7|1G|8|@$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|H|7|1J|8|@]|D|@]|E|$I|J]]|$1|R|3|S|5|6|7|1K|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|1L|8|@$9|1M|A|1N|B|C]]|D|@$9|1O|A|1P|1|1Q]|$9|1R|A|1S|1|1T]]|E|$]]|$1|V|3|-4|5|6|7|1U|8|@]|D|@]|E|$]]]|W|$X|$5|Y|Z|10|E|$11|12]]|13|$5|Y|Z|10|E|$11|14]]]]

To check at least <code>n</code> out of all <code>Boolean</code> are true, ( n must be less than or equal to total number of <code>Boolean</code> :p)

<pre><code>if (((a ? 1:0) + (b ? 1:0 ) + (c ? 1:0) + (d ? 1:0 )) &gt;= n) {
 // do the rest
}
</code></pre>

Edit : After @Cruncher's comment

To check 3 <code>boolean</code> out of 4

<pre><code>if (((a ? 1:0) + (b ? 1:0 ) + (c ? 1:0) + (d ? 1:0 )) == 3) {
 // do the rest
}
</code></pre>

Another one : 

<a href="https://www.wolframalpha.com/input/?i=%28%28c%20and%20d%29%20and%20%28a%20xor%20b%29%29%20or%20%28%28a%20and%20b%29%20and%20%28c%20xor%20d%29%29%20truth%20table" rel="nofollow"><code>((c &amp; d) &amp; (a ^ b)) | ((a &amp; b) &amp; (c ^ d))</code></a> (<a href="https://www.wolframalpha.com/input/?i=%28%28c%20and%20d%29%20and%20%28a%20xor%20b%29%29%20or%20%28%28a%20and%20b%29%20and%20%28c%20xor%20d%29%29" rel="nofollow">Details</a>)

blocks|key|657751|text|如果您想在编程语言中使用这个逻辑，我的建议是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|657752|bool+test(bool+a,+bool+b,+bool+c,+bool+d){
++++int+n1+=+a+?+1+:+0;
++++int+n2+=+b+?+1+:+0;
++++int+n3+=+c+?+1+:+0;
++++int+n4+=+d+?+1+:+0;

++++return+n1+%2B+n2+%2B+n3+%2B+n4+==+3;
}|code-block|syntax|javascript|657753|或者，如果您愿意，可以将所有这些都放在一行中：|657754|return+(a+?+1+:+0)+%2B+(b+?+1+:+0)+%2B+(C+?+1+:+0)+%2B+(d+?+1+:+0)+==+3;|657755|此外，您还可以将此问题推广到n+of+m：|offset|length|style|CODE|657756|bool+test(bool+*values,+int+n,+int+m){
++++int+sum+=+0;
++++for(int+i+=+0;+i+<+m;+i+%2B=+1){
++++++++sum+%2B=+values[i]+?+1+:+0;
++++}
++++return+sum+==+n;
}|657757|entityMap^0|0|0|0|0|E|6|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

If you want to use this logic in a programming language, my suggestion is

<pre><code>bool test(bool a, bool b, bool c, bool d){
 int n1 = a ? 1 : 0;
 int n2 = b ? 1 : 0;
 int n3 = c ? 1 : 0;
 int n4 = d ? 1 : 0;

 return n1 + n2 + n3 + n4 == 3;
}
</code></pre>

Or if you want, you can put all of these in a single line:

<pre><code>return (a ? 1 : 0) + (b ? 1 : 0) + (C ? 1 : 0) + (d ? 1 : 0) == 3;
</code></pre>

Also you can generalize this problem to <code>n of m</code> :

<pre><code>bool test(bool *values, int n, int m){
 int sum = 0;
 for(int i = 0; i &lt; m; i += 1){
 sum += values[i] ? 1 : 0;
 }
 return sum == n;
}
</code></pre>

blocks|key|1656689|text|如果这是Python，我会写|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1656690|if+[a,+b,+c,+d].count(True)+==+3:|code-block|syntax|javascript|1656691|或|1656692|if+[a,+b,+c,+d].count(False)+==+1:|1656693|1656694|if+[a,+b,+c,+d].count(False)+==+True:
#+In+Python+True+==+1+and+False+==+0|1656695|1656696|print+[a,+b,+c,+d].count(0)+==+1|1656697|1656698|print+[a,+b,+c,+d].count(1)+==+3|1656699|1656700|if+a+%2B+b+%2B+c+%2B+d+==+3:|1656701|1656702|if+sum([a,+b,+c,+d])+==+3:|1656703|所有这些工作，因为Booleans是Python中整数的子类。|1656704|if+len(filter(bool,+[a,+b,+c,+d]))+==+3:|1656705|或者，受这个巧妙的诡计的启发，|offset|length|1656706|data+=+iter([a,+b,+c,+d])
if+not+all(data)+and+all(data):|1656707|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/16801605/1903116^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|6|5|0|0|0^^$0|@$1|2|3|4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1I|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1J|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1K|8|@]|9|@]|A|$E|F]]|$1|K|3|H|5|6|7|1L|8|@]|9|@]|A|$]]|$1|L|3|M|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|N|3|H|5|6|7|1N|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|1O|8|@]|9|@]|A|$E|F]]|$1|Q|3|H|5|6|7|1P|8|@]|9|@]|A|$]]|$1|R|3|S|5|D|7|1Q|8|@]|9|@]|A|$E|F]]|$1|T|3|H|5|6|7|1R|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1S|8|@]|9|@]|A|$E|F]]|$1|W|3|H|5|6|7|1T|8|@]|9|@]|A|$]]|$1|X|3|Y|5|D|7|1U|8|@]|9|@]|A|$E|F]]|$1|Z|3|10|5|6|7|1V|8|@]|9|@]|A|$]]|$1|11|3|12|5|D|7|1W|8|@]|9|@]|A|$E|F]]|$1|13|3|14|5|6|7|1X|8|@]|9|@$15|1Y|16|1Z|1|20]]|A|$]]|$1|17|3|18|5|D|7|21|8|@]|9|@]|A|$E|F]]|$1|19|3|-4|5|6|7|22|8|@]|9|@]|A|$]]]|1A|$1B|$5|1C|1D|1E|A|$1F|1G]]]]

If this had been Python, I would have written

<pre><code>if [a, b, c, d].count(True) == 3:
</code></pre>

Or

<pre><code>if [a, b, c, d].count(False) == 1:
</code></pre>

Or

<pre><code>if [a, b, c, d].count(False) == True:
# In Python True == 1 and False == 0
</code></pre>

Or

<pre><code>print [a, b, c, d].count(0) == 1
</code></pre>

Or

<pre><code>print [a, b, c, d].count(1) == 3
</code></pre>

Or

<pre><code>if a + b + c + d == 3:
</code></pre>

Or

<pre><code>if sum([a, b, c, d]) == 3:
</code></pre>

All these work, since Booleans are subclasses of integers in Python.

<pre><code>if len(filter(bool, [a, b, c, d])) == 3:
</code></pre>

Or, inspired by this <a href="https://stackoverflow.com/a/16801605/1903116">neat trick</a>,

<pre><code>data = iter([a, b, c, d])
if not all(data) and all(data):
</code></pre>

blocks|key|1377835|text|((a+xor+b)+xor+(c+xor+d))+and+((a+or+b)+and+(c+or+d))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1377836|第一个表达式搜索4中的1或3true，第二个表达式消除0或1(有时是2)+4中的true。|unstyled|offset|length|style|CODE|1377837|entityMap^0|0|E|4|14|4|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]|$G|Q|H|R|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|S|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>((a xor b) xor (c xor d)) and ((a or b) and (c or d))
</code></pre>

The fist expression searchs for 1 or 3 <code>true</code>'s out of 4. The second one eliminates 0 or 1 (and sometimes 2) <code>true</code>'s out of 4.

blocks|key|657860|text|(a+&&+b+&&+(c+xor+d))+%7C%7C+(c+&&+d+&&+(a+xor+b))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|657861|从纯粹的逻辑角度来看，这就是我想出的。|unstyled|657862|根据鸽子洞原理，如果精确3为真，则a和b为真，或c和d为真。然后，这只是一个问题，与其他两个案件中的一个。|657863|Wolfram真值表|offset|length|657864|entityMap|0|LINK|mutability|MUTABLE|url|https://www.wolframalpha.com/input/?i=%2528a%2520and%2520b%2520and%2520%2528c%2520xor%2520d%2529%2529%2520%257C%257C%2520%2528c%2520and%2520d%2520and%2520%2528a%2520xor%2520b%2529%2529%2520truth%2520table^0|0|0|0|0|A|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|F|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

<pre><code>(a &amp;&amp; b &amp;&amp; (c xor d)) || (c &amp;&amp; d &amp;&amp; (a xor b))
</code></pre>

From a pure logic point of view this is what I came up with.

By the pigeon hole principle, if exactly 3 are true, then either a and b is true, or c and d is true. Then its just a matter of anding each of those cases with exactly one of the other 2.

<a href="https://www.wolframalpha.com/input/?i=%28a%20and%20b%20and%20%28c%20xor%20d%29%29%20%7C%7C%20%28c%20and%20d%20and%20%28a%20xor%20b%29%29%20truth%20table" rel="noreferrer">Wolfram truth table</a>

blocks|key|1377890|text|我想返回true当且仅当4个布尔值中有3个为真。|type|blockquote|depth|inlineStyleRanges|entityRanges|data|1377891|给定4个布尔值a、b、x、y，此任务转换为以下C语句：|unstyled|1377892|return+(a%2Bb%2Bx%2By)+==+3;|code-block|syntax|javascript|1377893|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|M|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|N|8|@]|9|@]|A|$H|I]]|$1|J|3|-4|5|D|7|O|8|@]|9|@]|A|$]]]|K|$]]

<blockquote>
 I want to return true if and only if 3 out of 4 boolean values are true.
</blockquote>

Given the 4 boolean values, a, b, x, y, this task translates into the following C statement:

<pre><code>return (a+b+x+y) == 3;
</code></pre>

blocks|key|657969|text|如果您使用像卡诺地图这样的逻辑可视化工具，您就会发现，如果您想在一个If+(.)中编写一个完整的逻辑术语，就无法避免这个问题。线路。洛皮纳已经证明了，不可能把它写得更简单。你可以稍微考虑一下，但对你和机器来说，阅读起来还是很难的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|657970|计算解决方案并不坏，它们显示出你真正想要的是什么。如何有效地进行计数取决于您的编程语言。使用Python的数组解决方案是不错的，但是请注意，这是缓慢的。沃尔夫(a%2Bb%2Bx%2By)的==3工作得很快，但前提是你的语言等同于"true“和1。如果"true”由-1表示，则必须测试-3+:)|657971|如果您的语言使用真正的布尔语，您可以尝试显式地对它进行编程(我使用!=+as+XOR测试)：|657972|if+(a)
{
++++if+(b)
++++++++return+(x+!=+y);++++//+a,b=true,+so+either+x+or+y+must+be+true
++++else
++++++++return+(x+&&+y);+++++//+a=true,+b=false,+so+x+AND+y+must+be+true
}
else
{
++++if+(b)
++++++++return+(x+&&+y);++++//+a=false,+b=true,+so+x+and+y+must+be+true
++++else
++++++++return+false;+++++++//+a,b+false,+can't+get+3+of+4
}|code-block|syntax|javascript|657973|只有当x，y是布尔型时，"x+!=+y“才能工作。如果它们是其他类型，其中0为false，而其他为true，则可能会失败。然后使用布尔异或，或者(+(bool)x+!=+(bool)y+)，或者写"if+(x)返回(y==false)+or+(y==true);"，这对计算机来说是更多的工作。|657974|如果编程语言提供三元操作符，则可以将其缩短为|657975|if+(a)
++++return+b+?+(x+!=+y)+:+(x+&&+y);
else
++++return+b+?+(x+&&+y)+:+false;|657976|它保持了一定的可读性，或者将其积极地削减到|657977|return+a+?+(b+?+(x+!=+y)+:+(x+&&+y))+:+(b+?+(x+&&+y)+:+false);|657978|这段代码做了三个逻辑测试(+a的状态，b的状态，x和y的比较)，并且应该比这里的大多数其他答案更快。但是你需要对它进行评论，否则3个月后你就不会明白了:)|657979|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|H|7|14|8|@]|9|@]|A|$I|J]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|H|7|16|8|@]|9|@]|A|$I|J]]|$1|U|3|V|5|6|7|17|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

If you use a logic visualization tool like Karnaugh Maps, you see that this is a problem where you can't avoid a full blown logic term if you want to write it in one if (...) line. Lopina showed it already, it's not possible to write it simpler. You can factor out a bit, but it will stay hard to read for you AND for the machine.

Counting solutions are not bad and they show what you are really after. How you do the counting efficiently depends on your programming language. The array solutions with Python oder LinQ are nice to look at, but beware, this is SLOW. Wolf's (a+b+x+y)==3 will work nicely and fast, but only if your language equates "true" with 1. If "true" is represented by -1, you will have to test for -3 :)

If your language uses true booleans, you could try to program it explicitly (I use != as XOR test):

<pre><code>if (a)
{
 if (b)
 return (x != y); // a,b=true, so either x or y must be true
 else
 return (x &amp;&amp; y); // a=true, b=false, so x AND y must be true
}
else
{
 if (b)
 return (x &amp;&amp; y); // a=false, b=true, so x and y must be true
 else
 return false; // a,b false, can't get 3 of 4
}
</code></pre>

"x != y" works only if x,y are of a boolean type. If they are some other type where 0 is false and everything else is true, this can fail. Then use a boolean XOR, or ( (bool)x != (bool)y ), or write "if (x) return (y==false) else return (y==true);", which is a bit more work for the computer.

If your programming language provides the ternary ?: operator, you can shorten it to

<pre><code>if (a)
 return b ? (x != y) : (x &amp;&amp; y);
else
 return b ? (x &amp;&amp; y) : false;
</code></pre>

which keeps a bit of readability, or cut it aggressively to

<pre><code>return a ? (b ? (x != y) : (x &amp;&amp; y)) : (b ? (x &amp;&amp; y) : false);
</code></pre>

This code does exactly three logic tests (state of a, state of b, comparison of x and y) and should be faster than most of the other answers here. But you need to comment it, or you won't understand it after 3 months :)

blocks|key|1656937|text|下面是用LINQ在C#中解决这个问题的一种方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1656938|bool+threeTrue+=+new[]+{+a,+b,+x,+y+}.Count(x+=>+x)+==+3;|code-block|syntax|javascript|1656939|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a way you could solve it in C# with LINQ:

<pre><code>bool threeTrue = new[] { a, b, x, y }.Count(x =&gt; x) == 3;
</code></pre>

blocks|key|658043|text|类似于第一个答案，但纯Java：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|658044|int+t(boolean+b)+{
++++return+(b)+?+1+:+0;
}

if+(t(x)+%2B+t(y)+%2B+t(a)+%2B+t(b)+==+3)+return+true;
return+false;|code-block|syntax|javascript|658045|我更喜欢将它们计数为整数，因为这样可以提高代码的可读性。|658046|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Similar to the first answer, but pure Java:

<pre><code>int t(boolean b) {
 return (b) ? 1 : 0;
}

if (t(x) + t(y) + t(a) + t(b) == 3) return true;
return false;
</code></pre>

I prefer counting them as integers because it makes for more readable code.

blocks|key|1378020|text|这里有很多很好的答案；这里有一个其他人还没有发布过的替代方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1378021|+a+?+(b+?+(c+%5E+d)+:+(c+&&+d))+:+(b+&&+c+&&+d)|code-block|syntax|javascript|1378022|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

There are a lot of good answers here; here is an alternate formulation which no one else has posted yet:

<pre><code> a ? (b ? (c ^ d) : (c &amp;&amp; d)) : (b &amp;&amp; c &amp;&amp; d)
</code></pre>

blocks|key|1657041|text|Java+8，过滤掉假值，并计数其余的真值：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1657042|public+static+long+count(Boolean...+values)+{
++++return+Arrays.stream(values).filter(t+->+t).count();
}|code-block|syntax|javascript|1657043|然后您可以按以下方式使用它：|1657044|if+(3+==+count(a,+b,+c,+d))+{
++++System.out.println("There...+are...+THREE...+lights!");
}|1657045|容易概括为检查n的m项是否为真。|offset|length|style|CODE|1657046|entityMap^0|0|0|0|0|7|1|9|1|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

Java 8, filter out the false values, and count the remaining true values:

<pre><code>public static long count(Boolean... values) {
 return Arrays.stream(values).filter(t -&gt; t).count();
}
</code></pre>

Then you can use it as follows:

<pre><code>if (3 == count(a, b, c, d)) {
 System.out.println("There... are... THREE... lights!");
}
</code></pre>

Easily generalizes to checking for <code>n</code> of <code>m</code> items being true.

blocks|key|1657070|text|在Python中，要查看有多少可迭代的元素是True，可以使用sum+(非常简单)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|1657071|设置|1657072|import+itertools

arrays+=+list(itertools.product(*[[True,+False]]*4))|code-block|syntax|javascript|1657073|实际测试|1657074|for+array+in+arrays:
++++print(array,+sum(array)==3)|1657075|输出|1657076|(True,+True,+True,+True)+False
(True,+True,+True,+False)+True
(True,+True,+False,+True)+True
(True,+True,+False,+False)+False
(True,+False,+True,+True)+True
(True,+False,+True,+False)+False
(True,+False,+False,+True)+False
(True,+False,+False,+False)+False
(False,+True,+True,+True)+True
(False,+True,+True,+False)+False
(False,+True,+False,+True)+False
(False,+True,+False,+False)+False
(False,+False,+True,+True)+False
(False,+False,+True,+False)+False
(False,+False,+False,+True)+False
(False,+False,+False,+False)+False|1657077|entityMap^0|1|6|V|3|0|0|2|0|0|0|4|0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|12|8|@$9|13|A|14|B|C]]|E|@]|F|$]]|$1|I|3|J|5|K|7|15|8|@]|E|@]|F|$L|M]]|$1|N|3|O|5|6|7|16|8|@$9|17|A|18|B|C]]|E|@]|F|$]]|$1|P|3|Q|5|K|7|19|8|@]|E|@]|F|$L|M]]|$1|R|3|S|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|E|@]|F|$]]|$1|T|3|U|5|K|7|1D|8|@]|E|@]|F|$L|M]]|$1|V|3|-4|5|6|7|1E|8|@]|E|@]|F|$]]]|W|$]]

In Python, to see how many of an iterable of elements are True, use <code>sum</code> (it's quite straightforward):

Setup

<pre><code>import itertools

arrays = list(itertools.product(*[[True, False]]*4))
</code></pre>

Actual Test

<pre><code>for array in arrays:
 print(array, sum(array)==3)
</code></pre>

Output

<pre><code>(True, True, True, True) False
(True, True, True, False) True
(True, True, False, True) True
(True, True, False, False) False
(True, False, True, True) True
(True, False, True, False) False
(True, False, False, True) False
(True, False, False, False) False
(False, True, True, True) True
(False, True, True, False) False
(False, True, False, True) False
(False, True, False, False) False
(False, False, True, True) False
(False, False, True, False) False
(False, False, False, True) False
(False, False, False, False) False
</code></pre>

blocks|key|1378103|text|((a%5Eb)%5E(x%5Ey))&((a%7Cb)&(x%7Cy))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1378104|是你想要的。基本上，我接受了您的代码，并添加了检查是否实际为3为真，而不是3为假。|unstyled|1378105|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>((a^b)^(x^y))&amp;((a|b)&amp;(x|y))
</code></pre>

is what you want. Basically I took your code and added checking if actually 3 are true and not 3 are false.

blocks|key|1657107|text|由于可读性是一个非常重要的问题，所以您可以使用描述性函数调用(包装任何建议的实现)。如果需要在多个地方执行此计算，则函数调用是实现重用的最佳方法，并明确说明您在做什么。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1657108|bool+exactly_three_true_from(bool+cond1,+bool+cond2,+bool+cond3,+bool+cond4)
{
++++//...
}|code-block|syntax|javascript|1657109|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Since readability is a big concern, you could use a descriptive function call (wrapping any of the suggested implementations). If this calculation needs to be done in multiple places, a function call is the best way to achieve reuse, and makes it clear exactly what you are doing.

<pre><code>bool exactly_three_true_from(bool cond1, bool cond2, bool cond3, bool cond4)
{
 //...
}
</code></pre>

blocks|key|1657131|text|一个没有答案的编程问题涉及递归？不可思议！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1657132|有足够的“四个真理中有三个”的答案，但这里有一个泛化(Java)版本，用于“完全不符合n真”(否则递归并不值得)，因为您可以：|1657133|public+static+boolean+containsTrues(boolean[]+someBooleans,
++++int+anIndex,+int+truesExpected,+int+truesFoundSoFar)+{
++if+(anIndex+>=+someBooleans.length)+{
++++return+truesExpected+==+truesFoundSoFar;+//+reached+end
++}
++int+falsesExpected+=+someBooleans.length+-+truesExpected;
++boolean+currentBoolean+=+someBooleans[anIndex];
++int+truesFound+=+truesFoundSoFar+%2B+(currentBoolean+?+1+:+0);
++if+(truesFound+>+truesExpected)+{
++++return+false;
++}
++if+(anIndex+-+truesFound+>+falsesExpected)+{
++++return+false;+//+too+many+falses
++}
++return+containsTrues(someBooleans,+anIndex+%2B+1,+truesExpected,
++++++truesFound);
}|code-block|syntax|javascript|1657134|这可以用如下所示的方式调用：|1657135|+boolean[]+booleans+=+{+true,+false,+true,+true,+false,+true,+true,+false+};
+containsTrues(booleans,+0,+5,+0);|1657136|它应该返回true+(因为8个值中有5个是真的，正如预期的那样)。对“真”和“假”这两个词不太满意，但现在想不出更好的名字了.注意，当发现了太多的true或太多的false值时，递归就停止了。|offset|length|style|CODE|1657137|entityMap^0|0|0|0|0|0|5|4|21|4|29|5|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@$O|10|P|11|Q|R]|$O|12|P|13|Q|R]|$O|14|P|15|Q|R]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|T|$]]

A programming question without an answer involving recursion? Inconceivable!

There are enough "exactly 3 out of 4 trues" answers, but here's a generalised (Java) version for "exactly m out of n trues" (otherwise recursion isn't really worth it) just because you can:

<pre class="lang-js prettyprint-override"><code>public static boolean containsTrues(boolean[] someBooleans,
 int anIndex, int truesExpected, int truesFoundSoFar) {
 if (anIndex &gt;= someBooleans.length) {
 return truesExpected == truesFoundSoFar; // reached end
 }
 int falsesExpected = someBooleans.length - truesExpected;
 boolean currentBoolean = someBooleans[anIndex];
 int truesFound = truesFoundSoFar + (currentBoolean ? 1 : 0);
 if (truesFound &gt; truesExpected) {
 return false;
 }
 if (anIndex - truesFound &gt; falsesExpected) {
 return false; // too many falses
 }
 return containsTrues(someBooleans, anIndex + 1, truesExpected,
 truesFound);
}
</code></pre>

This could be called with something like:

<pre class="lang-js prettyprint-override"><code> boolean[] booleans = { true, false, true, true, false, true, true, false };
 containsTrues(booleans, 0, 5, 0);
</code></pre>

which should return <code>true</code> (because 5 of 8 values were true, as expected). Not quite happy with the words "trues" and "falses", but can't think of a better name right now.... Note that the recursion stops when too many <code>true</code> or too many <code>false</code> values have been found.

blocks|key|1378225|text|在PHP中，使其更动态(以防您更改条件数等)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1378226|$min+=+6;
$total+=+10;

//+create+our+boolean+array+values
$arr+=+array_map(function($a){return+mt_rand(0,1)>0;},range(1,$total));

//+the+'check'
$arrbools+=+array_map(function($a){return+(int)$a;},$arr);
$conditionMet+=+array_sum($arrbools)>=$min;

echo+$conditionMet+?+"Passed"+:+"Failed";|code-block|syntax|javascript|1378227|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In PHP, making it more dynamic (just in case you change number of conditions, etc.):

<pre><code>$min = 6;
$total = 10;

// create our boolean array values
$arr = array_map(function($a){return mt_rand(0,1)&gt;0;},range(1,$total));

// the 'check'
$arrbools = array_map(function($a){return (int)$a;},$arr);
$conditionMet = array_sum($arrbools)&gt;=$min;

echo $conditionMet ? "Passed" : "Failed";
</code></pre>

blocks|key|1378229|text|这是对称布尔函数S₃(4)。对称布尔函数是一个布尔函数，它只依赖于输入集的数量，而不依赖于它们的输入。Knuth在“计算机编程艺术”第4卷7.1.2节中提到了这种类型的函数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1378230|S₃(4)可以通过以下7个操作来计算：|1378231|(x+&&+y+&&+(a+%7C%7C+b))+%5E+((x+%7C%7C+y)+&&+a+&&+b)|code-block|syntax|javascript|1378232|Knuth表明这是最优的，这意味着您不能在少于7个操作中使用普通操作符：&&,+%7C%7C+,+%5E,+<,和>。|1378233|但是，如果您想在使用1表示true，使用0表示false的语言中使用加法，也可以轻松地使用加法：|1378234|x+%2B+y+%2B+a+%2B+b+==+3|1378235|所以你的意图很清楚。|1378236|entityMap^0|8|5|0|0|5|0|0|10|E|1F|1|0|A|1|K|1|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|J|7|1D|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|1E|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|V|$]]

That is the symmetric Boolean function <code>S₃(4)</code>. A symmetric Boolean function is a boolean function which only depends on the quantity of inputs set, but doesn't depend on which inputs they are. Knuth mentions functions of this type in section 7.1.2 in Volume 4 of The Art of Computer Programming.

<code>S₃(4)</code> can be computed with 7 operations as follows:

<pre><code>(x &amp;&amp; y &amp;&amp; (a || b)) ^ ((x || y) &amp;&amp; a &amp;&amp; b)
</code></pre>

Knuth shows that this is optimal, meaning that you cannot do this in less than 7 operations using the normal operators: <code>&amp;&amp;, || , ^, &lt;,</code> and <code>&gt;</code>.

However if you want to use this in a language which uses <code>1</code> for true and <code>0</code> for false, you can also use addition easily:

<pre><code>x + y + a + b == 3
</code></pre>

which makes your intention quite clear.

blocks|key|658287|text|(((a+AND+b)+OR+(x+AND+y))+AND+((a+XOR+b)+OR+(x+XOR+y)))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|658288|虽然我可以证明这是一个很好的解决方案，但Sam的答案很容易写，也很容易理解。在我的书里让它变得更好。|unstyled|658289|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>(((a AND b) OR (x AND y)) AND ((a XOR b) OR (x XOR y)))
</code></pre>

While I could show that this is a good solution, Sam Hocevar's answer is easy both to write and understand later. In my book that makes it better.

blocks|key|658329|text|以下是我刚刚编写的一些c#代码，因为您给了我灵感：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|658330|它需要任何数量的论点，并会告诉你，如果其中n是真的。|658331|++++static+bool+boolTester(int+n,+params+bool[]+values)
++++{
++++++++int+sum+=+0;+++++++++++

++++++++for+(int+i+=+0;+i+<+values.Length;+i%2B%2B)
++++++++{
++++++++++++if+(values[i]+==+true)
++++++++++++{
++++++++++++++++sum+%2B=+1;
++++++++++++}++++++++++++++++
++++++++}
++++++++if(+sum+==+n)
++++++++{
++++++++++++return+true;
++++++++}++++++++++++
++++++++return+false;++++++++++++++++
++++}|code-block|syntax|javascript|658332|你这样称呼它：|658333|++++++++bool+a+=+true;
++++++++bool+b+=+true;
++++++++bool+c+=+true;
++++++++bool+d+=+false;++++++++++++

++++++++bool+test+=+false;
++++++++test+=+boolTester(3,+a,+b,+c,+d);|658334|因此，现在您可以测试7/9或15/100，如您所愿。|658335|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Here is some c# code I just wrote because you have inspired me:

It takes any amount of arguments and will tell you if n of them are true. 

<pre class="lang-cs prettyprint-override"><code> static bool boolTester(int n, params bool[] values)
 {
 int sum = 0; 

 for (int i = 0; i &lt; values.Length; i++)
 {
 if (values[i] == true)
 {
 sum += 1;
 } 
 }
 if( sum == n)
 {
 return true;
 } 
 return false; 
 }
</code></pre>

and you call it like so:

<pre class="lang-cs prettyprint-override"><code> bool a = true;
 bool b = true;
 bool c = true;
 bool d = false; 

 bool test = false;
 test = boolTester(3, a, b, c, d);
</code></pre>

So you can now test 7/9 or 15/100 as you will.

I want to return <code>True</code> if and only if 3 out of 4 boolean values are true.

The closest I've gotten is <a href="https://www.wolframalpha.com/input/?i=(x+xor+y)+xor+(a+xor+b)+truth+table" rel="noreferrer"><code>(x ^ y) ^ (a ^ b)</code></a>:

<img src="https://i.stack.imgur.com/X6XCi.gif" alt="">

What should I do?

Logic to test that 3 of 4 are True

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想返回True当且仅当4个布尔值中有3个为真。我得到的最接近的是​​我该怎么办？

问逻辑测试4中的3是真
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问逻辑测试4中的3是真EN