Check if at least two out of three booleans are true

Question

An interviewer recently asked me this question  given three boolean variables  a  b  and c  return true if at least two out of the three are true   My solution follows   boolean atLeastTwo boolean a  boolean b  boolean c        if   a  amp  amp  b      b  amp  amp  c      a  amp  amp  c             return true            else          return false            He said that this can be improved further  but how

User · Answer

C   if    a     b     c  gt   2

User · Answer

It seems to me that three out of three are quite arbitrary numbers  and the function should work with an arbitrary number  So in order to answer the question  I d write a function that would work out if x in an array were true  for example   bool istrue   int x  bool   list      y   count true in list     return y  gt   x

User · Answer

int count 0   boolean atLeastTwo boolean a  boolean b  boolean c        if  a          count        if  b          count        if  c          count         if  count gt 1          return true      else         return false

User · Answer

In Clojure    defn at-least  n  amp  bools      gt    count  filter true  bools   n    Usage    at-least 2 true false true

User · Answer

This kind of questions can be solved with a Karnaugh Map           C    C ------ --- ----  A  B   1   1   A  B   1   0  A  B   0   0  A  B   1   0   from which you infer that you need a group for first row and two groups for first column  obtaining the optimal solution of polygenelubricants    C  amp  amp   A    B       A  amp  amp  B    lt ---- first row                      first column without third case

User · Answer

My first thought was  return  a  b  amp  amp  b  c    but for ease of reading I liked the proposed a b c  2 solution that you guys suggested better

User · Answer

If the goal is to return a bitwise two-out-of-three value for three operands  arithmetic and iterative approaches are apt to be relatively ineffective   On many CPU architectures  a good form would be  return   a   b   amp  c     a  amp  b      That takes four boolean operations   On single-accumulator machines  common in small embedded systems  that s apt to take a total of seven instructions per byte   The form  return  a  amp  b     a  amp  c     b  amp  c    is perhaps nicer looking  but it would require five boolean operations  or nine instructions per byte on a single-accumulator machine   Incidentally  in CMOS logic  computing  not two out of three  requires twelve transistors  for comparison  an inverter requires two  a two-input NAND or NOR requires four  and a three-input NAND or NOR requires six

User · Answer

Ternary operators get the nerd juices flowing  but they can be confusing  making code less maintainable  thus increasing the potential for bug injection   Jeff Attwood said it well here      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    Avoiding ternary operators  I ve created the following function   function atLeastTwoTrue  a   b   c             count   0           if   a     count              if   b     count              if   c     count               if   count  gt   2                    return true            else                   return false                Is this as cool as some of the other solutions  No  Is it easier to understand  Yes  Will that lead to more maintainable  less buggy code  Yes

User · Answer

Currenty with Java 8  I really prefer something like this   boolean atLeastTwo boolean a  boolean b  boolean c        return Stream of a  b  c  filter active - gt  active  count    gt   2

User · Answer

We can convert the bools to integers and perform this easy check    int a    int b    int c    gt   2

User · Answer

In C   off of the top of my head   public bool lol int minTrue  params bool   bools        return bools Count    b     gt  b    gt   minTrue      should be pretty quick   A call would look like this   lol  2  true  true  false      This way  you are leaving the rules  two must be true  up to the caller  instead of embedding them in the method

User · Answer

Another one   return a  b  c   b amp  amp c

User · Answer

Yet another way to do this but not a very good one   return  Boolean valueOf a  hashCode     Boolean valueOf b  hashCode     Boolean valueOf c  hashCode     lt  3705     The Boolean hashcode values are fixed at 1231 for true and 1237 for false so could equally have used  lt   3699

User · Answer

Just for the sake of using XOR to answer a relatively straight-forward problem     return a   b   c   a

User · Answer

return  a  b    a   c    Explanation   If a  b  then both are true or both are false  If both are true  we have found our two true booleans  and can return true  by returning a   If both are false there cannot be two true booleans even if c is true  so we return false  by returning a   That s the  a  b    a part  What about   c   Well if a  b is false  then exactly one of a or b must be true  so we have found the first true boolean  and the only thing left that matters is if c is also true  so we return c as the answer

User · Answer

Here s a test-driven  general approach   Not as  efficient  as most of the solutions so far offered  but clear  tested  working  and generalized   public class CountBooleansTest extends TestCase       public void testThreeFalse   throws Exception           assertFalse atLeastTwoOutOfThree false  false  false               public void testThreeTrue   throws Exception           assertTrue atLeastTwoOutOfThree true  true  true               public void testOnes   throws Exception           assertFalse atLeastTwoOutOfThree true  false  false            assertFalse atLeastTwoOutOfThree false  true  false            assertFalse atLeastTwoOutOfThree false  false  true               public void testTwos   throws Exception           assertTrue atLeastTwoOutOfThree false  true  true            assertTrue atLeastTwoOutOfThree true  false  true            assertTrue atLeastTwoOutOfThree true  true  false               private static boolean atLeastTwoOutOfThree boolean b  boolean c  boolean d            return countBooleans b  c  d   gt   2             private static int countBooleans boolean    bs            int count   0          for  boolean b   bs              if  b                  count            return count

User · Answer

Definitely a question that s more about how you solve problems think than your actual coding ability   A slightly terser version could be     return   a   b   amp  amp   b   c     b   But like a previous poster said  if I saw this in any code I was working on  someone would be getting an earful

User · Answer

He s probably not looking for anything convoluted like bitwise comparison operators  not normally convoluted but with booleans  it s extremely odd to use bitwise operators  or something that is very roundabout like converting to int and summing them up   The most direct and natural way to solve this is with an expression like this   a    b    c    b  amp  amp  c    Put it in a function if you prefer  but it s not very complicated  The solution is logically concise and efficient

User · Answer

Not in context of performance but good code extensible and readable code that can be reused        static boolean trueBooleans  int howMany boolean     bools               int total   0         for  boolean b bools          if  b  amp  amp     total    howMany   return true          return false          In my humble opinion when writing Java  easy handling unexpected changes and no duplicated code are more important than concise  domain of script languages  or fast program

User · Answer

X   OR a b c   a b c X  1 1 0 1  0 0 1 1  0 1 1 1

User · Answer

How about this one    a - b    c   a

User · Answer

If I convert the booleans into a number  and if the number is not a power of two  it has at least two trues    a 4   b 2   c 1   N return  N    0  amp  amp   N amp  N-1      0    I am just giving an alternative

User · Answer

function atLeastTwoTrue  a   b   c       int count   0    count    a   count   1   count     count    b   count   1   count     count    c   count   1   count     return  count    2

User · Answer

It should be    a    b  amp  amp  c   amp  amp   b    c  amp  amp  a    Also  if true is automatically converted to 1 and false to 0    a   b c     b   c a   gt  0

User · Answer

Here s another implementation using map reduce  This scales well to billions of booleans   in a distributed environment  Using MongoDB   Creating a database values of booleans   db values insert  value  true    db values insert  value  false    db values insert  value  true      Creating the map  reduce functions   Edit  I like CurtainDog s answer about having map reduce apply to generic lists  so here goes a map function which takes a callback that determines whether a value should be counted or not   var mapper   function shouldInclude        return function             emit null  shouldInclude this    1   0             var reducer   function key  values        var sum   0      for var i   0  i  lt  values length  i              sum    values i             return sum      Running map reduce   var result   db values mapReduce mapper isTrue   reducer  result   containsMinimum 2  result      true containsMinimum 1  result      false   function isTrue object        return object value    true     function containsMinimum count  resultDoc        var record   db resultDoc  find   next        return record value  gt   count

User · Answer

In C   return   a     b     c  gt   2

User · Answer

The non-reduced solution to this problem is   a bc   abc    abc   ab c   Reducing using K-Maps  one gets   bc   ab   ac   One could reduce this further by using exclusive or on the a bc and abc  minterms and combining the abc and ab c minterms   b a   c    ac

User · Answer

Sum it up  It s called boolean algebra for a reason     0 x 0   0   1 x 0   0   1 x 1   1    0   0   0   1   0   1   1   1   0    carry    If you look at the truth tables there  you can see that multiplication is boolean and  and simply addition is xor   To answer your question    return  a   b   c   gt   2

User · Answer

This sort of is reading better   if  a        return b    c     else       return b  amp  amp  c

User · Answer

The most obvious set of improvements are      There is no point in an else if you already returned  boolean atLeastTwo boolean a  boolean b  boolean c        if   a  amp  amp  b      b  amp  amp  c      a  amp  amp  c             return true            return false      and then     There is no point in an if true  return true otherwise return false  boolean atLeastTwo boolean a  boolean b  boolean c        return   a  amp  amp  b      b  amp  amp  c      a  amp  amp  c        But those improvements are minor

User · Answer

Function ko returns the answer   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   gt   2   true   false

User · Answer

The simplest way  IMO  that is not confusing and easy to read      Three booleans  check if two or more are true  return   a  amp  amp    b    c          b  amp  amp  c

User · Answer

A literal interpretation will work in all major languages   return  a   1 0     b   1 0     c   1 0   gt   2    But I would probably make it easier for people to read  and expandable to more than three - something that seems to be forgotten by many programmers   boolean testBooleans Array bools         int minTrue   ceil bools length    5        int trueCount   0        for int i   0  i  lt  bools length  i                     if bools i                              trueCount                            return trueCount  gt   minTrue

User · Answer

public static boolean atLeast int atLeastToBeTrue  boolean   bools       int booleansTrue   0      for boolean tmp   bools           booleansTrue    tmp   1   0            return booleansTrue  gt   atLeastToBeTrue      You can choose how many at least you want to be true from varargs a k a boolean    -

User · Answer

Why not implement it literally       a 1 0   b 1 0   c 1 0   gt   2   In C you could just write a b c  gt   2  or   a   b   c  gt   2 to be very safe    In response to TofuBeer s comparison of java bytecode  here is a simple performance test   class Main       static boolean majorityDEAD boolean a boolean b boolean c                return a             static boolean majority1 boolean a boolean b boolean c                return a amp  amp b    b amp  amp c    a amp  amp c             static boolean majority2 boolean a boolean b boolean c                return a   b  c   b amp  amp c             static boolean majority3 boolean a boolean b boolean c                return a amp b   b amp c   c amp a             static boolean majority4 boolean a boolean b boolean c                return  a 1 0   b 1 0   c 1 0   gt   2             static int loop1 boolean   data  int i  int sz1  int sz2                int sum   0          for int j i j lt i sz1 j                          for int k j k lt j sz2 k                                  sum    majority1 data i   data j   data k   1 0                   sum    majority1 data i   data k   data j   1 0                   sum    majority1 data j   data k   data i   1 0                   sum    majority1 data j   data i   data k   1 0                   sum    majority1 data k   data i   data j   1 0                   sum    majority1 data k   data j   data i   1 0                                   return sum             static int loop2 boolean   data  int i  int sz1  int sz2                int sum   0          for int j i j lt i sz1 j                          for int k j k lt j sz2 k                                  sum    majority2 data i   data j   data k   1 0                   sum    majority2 data i   data k   data j   1 0                   sum    majority2 data j   data k   data i   1 0                   sum    majority2 data j   data i   data k   1 0                   sum    majority2 data k   data i   data j   1 0                   sum    majority2 data k   data j   data i   1 0                                   return sum             static int loop3 boolean   data  int i  int sz1  int sz2                int sum   0          for int j i j lt i sz1 j                          for int k j k lt j sz2 k                                  sum    majority3 data i   data j   data k   1 0                   sum    majority3 data i   data k   data j   1 0                   sum    majority3 data j   data k   data i   1 0                   sum    majority3 data j   data i   data k   1 0                   sum    majority3 data k   data i   data j   1 0                   sum    majority3 data k   data j   data i   1 0                                   return sum             static int loop4 boolean   data  int i  int sz1  int sz2                int sum   0          for int j i j lt i sz1 j                          for int k j k lt j sz2 k                                  sum    majority4 data i   data j   data k   1 0                   sum    majority4 data i   data k   data j   1 0                   sum    majority4 data j   data k   data i   1 0                   sum    majority4 data j   data i   data k   1 0                   sum    majority4 data k   data i   data j   1 0                   sum    majority4 data k   data j   data i   1 0                                   return sum             static int loopDEAD boolean   data  int i  int sz1  int sz2                int sum   0          for int j i j lt i sz1 j                          for int k j k lt j sz2 k                                  sum    majorityDEAD data i   data j   data k   1 0                   sum    majorityDEAD data i   data k   data j   1 0                   sum    majorityDEAD data j   data k   data i   1 0                   sum    majorityDEAD data j   data i   data k   1 0                   sum    majorityDEAD data k   data i   data j   1 0                   sum    majorityDEAD data k   data j   data i   1 0                                   return sum             static void work                 boolean    data   new boolean  10000           java util Random r   new java util Random 0           for int i 0 i lt data length i                data i    r nextInt 2   gt  0          long t0 t1 t2 t3 t4 tDEAD          int sz1   100          int sz2   100          int sum   0           t0   System currentTimeMillis             for int i 0 i lt data length-sz1-sz2 i                sum    loop1 data  i  sz1  sz2            t1   System currentTimeMillis             for int i 0 i lt data length-sz1-sz2 i                sum    loop2 data  i  sz1  sz2            t2   System currentTimeMillis             for int i 0 i lt data length-sz1-sz2 i                sum    loop3 data  i  sz1  sz2            t3   System currentTimeMillis             for int i 0 i lt data length-sz1-sz2 i                sum    loop4 data  i  sz1  sz2            t4   System currentTimeMillis             for int i 0 i lt data length-sz1-sz2 i                sum    loopDEAD data  i  sz1  sz2            tDEAD   System currentTimeMillis             System out println  a amp  amp b    b amp  amp c    a amp  amp c        t1-t0      ms            System out println     a   b  c   b amp  amp c          t2-t1      ms            System out println     a amp b   b amp c   c amp a          t3-t2      ms            System out println     a   b   c  gt   2           t4-t3      ms            System out println         DEAD                 tDEAD-t4      ms            System out println  sum    sum              public static void main String   args  throws InterruptedException               while true                        work                Thread sleep 1000                       This prints the following on my machine  running Ubuntu on Intel Core 2   sun java 1 6 0 15-b03 with HotSpot Server VM  14 1-b02  mixed mode     First and second iterations   a amp  amp b    b amp  amp c    a amp  amp c   1740 ms    a   b  c   b amp  amp c     1690 ms    a amp b   b amp c   c amp a     835 ms    a   b   c  gt   2      348 ms        DEAD            169 ms sum  1472612418   Later iterations   a amp  amp b    b amp  amp c    a amp  amp c   1638 ms    a   b  c   b amp  amp c     1612 ms    a amp b   b amp c   c amp a     779 ms    a   b   c  gt   2      905 ms        DEAD            221 ms   I wonder  what could java VM do that degrades performance over time for  a   b   c    2  case   And here is what happens if I run java with a -client VM switch   a amp  amp b    b amp  amp c    a amp  amp c   4034 ms    a   b  c   b amp  amp c     2215 ms    a amp b   b amp c   c amp a     1347 ms    a   b   c  gt   2      6589 ms        DEAD            1016 ms   Mystery     And if I run it in GNU Java Interpreter  it gets almost 100 times slower  but the a amp  amp b    b amp  amp c    a amp  amp c version wins then   Results from Tofubeer with the latest code running OS X   a amp  amp b    b amp  amp c    a amp  amp c   1358 ms    a   b  c   b amp  amp c     1187 ms    a amp b   b amp c   c amp a     410 ms    a   b   c  gt   2      602 ms        DEAD            161 ms   Results from  Paul Wagland with a Mac Java 1 6 0 26-b03-383-11A511  a amp  amp b    b amp  amp c    a amp  amp c   394 ms     a   b  c   b amp  amp c     435 ms    a amp b   b amp c   c amp a     420 ms    a   b   c  gt   2      640 ms    a   b   c   a       571 ms    a    b   c   a      487 ms        DEAD            170 ms

User · Answer

Rather than writing   if  someExpression        return true    else       return false      Write   return someExpression      As for the expression itself  something like this   boolean atLeastTwo boolean a  boolean b  boolean c        return a    b    c     b  amp  amp  c       or this  whichever you find easier to grasp    boolean atLeastTwo boolean a  boolean b  boolean c        return a  amp  amp   b    c      b  amp  amp  c       It tests a and b exactly once  and c at most once   References   JLS 15 25 Conditional Operator

User · Answer

It really depends what you mean by  improved    Clearer   boolean twoOrMoreAreTrue boolean a  boolean b  boolean c        return  a  amp  amp  b      a  amp  amp  c      b  amp  amp  c       Terser   boolean moreThanTwo boolean a  boolean b  boolean c        return a    b   a   c      More general   boolean moreThanXTrue int x  boolean   bs        int count   0       for boolean b   bs                count    b   1   0           if count  gt  x  return true             return false      More scalable   boolean moreThanXTrue int x  boolean   bs        int count   0       for int i  lt  0  i  lt  bs length  i                  count    bs i    1   0           if count  gt  x  return true           int needed   x - count          int remaining   bs length - i           if needed  gt   remaining  return false             return false      Faster      Only profiling can answer this    Which one is  improved  depends heavily on the situation

User · Answer

FYI  this is just the carry-out bit of a full adder  In hardware  you could use the logical effort to determine the optimal circuit based on the different boolean expressions  I would guess that the traditional XOR solution would take more effort than the less succinct expression that the poster presented

User · Answer

I believe using plain boolean operators  a    b   amp  amp   b    c  is fine and is simpler   You can swap any of the 3 letters with any of the other two and it s still the same expresion

User · Answer

My first thought when I saw the question was   int count 0  if  a        count  if  b        count  if  c        count  return count gt  2    After seeing other posts  I admit that  return  a 1 0   b 1 0   c 1 0  gt  2    is much more elegant  I wonder what the relative runtimes are   In any case  though  I think this sort of solution is much better than a solution of the  return a amp b   b amp c   a amp c    variety because is is more easily extensible  What if later we add a fourth variable that must be tested  What if the number of variables is determined at runtime  and we are passed an array of booleans of unknown size  A solution that depends on counting is much easier to extend than a solution that depends on listing every possible combination  Also  when listing all possible combinations  I suspect that it is much easier to make a mistake  Like try writing the code for  any 3 of 4  and make sure you neither miss any nor duplicate any  Now try it with  any 5 of 7

User · Answer

As an addition to  TofuBeer TofuBeer s excellent post  consider  pdox pdox s answer   static boolean five final boolean a  final boolean b  final boolean c        return a    b   a   c      Consider also its disassembled version as given by  javap -c    static boolean five boolean  boolean  boolean     Code      0     iload 0     1     iload 1     2     if icmpne    9     5     iload 0     6     goto    10     9     iload 2    10     ireturn   pdox s answer compiles to less byte code than any of the previous answers  How does its execution time compare to the others   one                5242 ms two                6318 ms three  moonshadow  3806 ms four               7192 ms five   pdox        3650 ms   At least on my computer  pdox s answer is just slightly faster than  moonshadow moonshadow s answer  making pdox s the fastest overall  on my HP Intel laptop

User · Answer

Since it wasn t specified how the code should be improved  I shall endeavour to improve the code by making it more amusing  Here s my solution   boolean atLeastTwo boolean t  boolean f  boolean True        boolean False   True      if   t    f   amp  amp   True    False            return  answer      42       if  t  amp  amp  f           return   France  contains  Paris        if  False    True           return true    false      return Math random    gt  0 5      In case anyone s wondering if this code works  here s a simplification using the same logic   boolean atLeastTwo boolean a  boolean b  boolean c        if   a    b   amp  amp   c            return true      if  a  amp  amp  b           return true      if  true           return false         The last line is a red herring  as it will never be reached      return Math random    gt  0 5        This can be boiled down further to the following   return   a    b   amp  amp   c       a  amp  amp  b     But now it s not funny any more

User · Answer

The simplest form using ternary operators to solve the problem is   return a    b   true   c     b   c   false     You may also want to invest finding a solution by using double negation of the requirement  meaning to say  instead of at least two true values  you need to satisfy the condition at most one false value

User · Answer

boolean atLeastTwo boolean a  boolean b  boolean c       return   a  amp  amp  b      b  amp  amp  c      a  amp  amp  c

User · Answer

The 2 and 3 in the question posed are decidedly magic-numberish  The  correct  answer will depend on whether the interviewer was trying to get at your grasp of boolean logic  and I don t think pdox s answer could be bested in this respect  or your understanding of architectural issues   I d be inclined to go with a map-reduce solution that will accept any sort of list with any arbitrary condition

User · Answer

I found this solution   boolean atLeastTwo boolean a  boolean b  boolean c        bool result     a   b   c   amp  amp     a  amp   b  amp   c      a  amp  b  amp  c       return result

User · Answer

Taking another approach to this using Java 8 s Stream functionality  for any number of booleans with an arbitrary required amount  The Stream short circuits if it hits the limit before processing all of the elements   public static boolean atLeastTrue int amount  Boolean     booleans        return Stream of booleans  filter b - gt  b  limit amount  count      amount     public static void main String   args       System out println  1 2      atLeastTrue 1  true  false  true        System out println  1 1      atLeastTrue 1  false  true        System out println  1 0      atLeastTrue 1  false        System out println  1 1      atLeastTrue 1  true  false        System out println  2 3      atLeastTrue 2  true  false  true  true        System out println  3 2      atLeastTrue 3  true  false  true  false        System out println  3 3      atLeastTrue 3  true  true  true  false        Output   1 2  true 1 1  true 1 0  false 1 1  true 2 3  true 3 2  false 3 3  true

User · Answer

The best answer to the question should be  As an employee  it s important I write it so that my meaning is clear while maintaining efficiency where necessary for performance    Here s how I d write it   function atLeastTwoAreTrue a  b  c        return  a  amp  amp  b      b  amp  amp  c      a  amp  amp  c       In reality  the test is so contrived that writing a method that s the fastest  most cryptic possible is perfect acceptable if you accomodate it with a simple comment   But  in general  in this one-liner world  we need more readable code in this world   -

User · Answer

Another example of direct code   int  n   0  if  a  n    if  b  n    if  c  n    return  n  gt   2     It s not the most succinct code  obviously   Addendum  Another  slightly optimized  version of this   int  n   -2  if  a  n    if  b  n    if  c  n    return  n  gt   0     This might run slightly faster  assuming that the comparison against 0 will use faster  or perhaps less  code than the comparison against 2

User · Answer

I don t like ternary  return a    b    c     b  amp  amp  c   from the top answer   and I don t think I ve seen anyone mention it  It is written like this   boolean atLeastTwo boolean a  boolean b  boolean c        if  a            return b  c             else           return b amp  amp C

User · Answer

Readability should be the goal  Someone who reads the code must understand your intent immediately  So here is my solution   int howManyBooleansAreTrue          a   1   0         b   1   0         c   1   0    return howManyBooleansAreTrue  gt   2

User · Answer

Function ReturnTrueIfTwoIsTrue bool val1  val2  val3          return  System Convert ToInt16 val1                 System Convert ToInt16 val2                 System Convert ToInt16 val3    gt  1      Too many ways to do this

User · Answer

In Ruby    a  b  c  count    x  x    gt   2  Which could be run in JRuby on the JavaVM   -

User · Answer

A C solution   int two int a  int b  int c      return  a    b    c  lt  2      or you may prefer   int two int a  int b  int c      return   a     b     c  gt   2

User · Answer

Calculated via a truth table   return  a  amp  b     c  amp   a   b

User · Answer

One thing I haven t seen others point out is that a standard thing to do in the  please write me some code  section of the job interview is to say  Could you improve that   or  Are you completely happy with that  or  is that as optimized as possible   when you say you are done  It s possible you heard  how would you improve that  as  this might be improved  how    In this case changing the if x  return true  else return false  idiom to just return x is an improvement - but be aware that there are times they just want to see how you react to the question  I have heard that some interviewers will insist there is a flaw in perfect code just to see how you cope with it

User · Answer

Taking the answers  so far  here   public class X       static boolean a final boolean a  final boolean b  final boolean c            return   a  amp  amp  b      b  amp  amp  c      a  amp  amp  c               static boolean b final boolean a  final boolean b  final boolean c            return a    b    c     b  amp  amp  c              static boolean c final boolean a  final boolean b  final boolean c            return   a  amp  b     b  amp  c     c  amp  a               static boolean d final boolean a  final boolean b  final boolean c            return   a 1 0   b 1 0   c 1 0   gt   2             and running them through the decompiler  javap -c X   results txt    Compiled from  X java  public class X extends java lang Object  public X      Code     0    aload 0    1    invokespecial    1    Method java lang Object   lt init gt     V    4    return  static boolean a boolean  boolean  boolean     Code     0    iload 0    1    ifeq    8    4    iload 1    5    ifne    24    8    iload 1    9    ifeq    16    12   iload 2    13   ifne    24    16   iload 0    17   ifeq    28    20   iload 2    21   ifeq    28    24   iconst 1    25   goto    29    28   iconst 0    29   ireturn  static boolean b boolean  boolean  boolean     Code     0    iload 0    1    ifeq    20    4    iload 1    5    ifne    12    8    iload 2    9    ifeq    16    12   iconst 1    13   goto    33    16   iconst 0    17   goto    33    20   iload 1    21   ifeq    32    24   iload 2    25   ifeq    32    28   iconst 1    29   goto    33    32   iconst 0    33   ireturn  static boolean c boolean  boolean  boolean     Code     0    iload 0    1    iload 1    2    iand    3    iload 1    4    iload 2    5    iand    6    ior    7    iload 2    8    iload 0    9    iand    10   ior    11   ireturn  static boolean d boolean  boolean  boolean     Code     0    iload 0    1    ifeq    8    4    iconst 1    5    goto    9    8    iconst 0    9    iload 1    10   ifeq    17    13   iconst 1    14   goto    18    17   iconst 0    18   iadd    19   iload 2    20   ifeq    27    23   iconst 1    24   goto    28    27   iconst 0    28   iadd    29   iconst 2    30   if icmplt   37    33   iconst 1    34   goto    38    37   iconst 0    38   ireturn     You can see that the    ones are slightly better then the fixed up version of your original   The one that is the best is the one that avoids branching altogether   That is good from the point of view of fewer instructions  in most cases  and better for branch prediction parts of the CPU  since a wrong guess in the branch prediction can cause CPU stalling    I d say the most efficient one is the one from moonshadow overall   It uses the fewest instructions on average and reduces the chance for pipeline stalls in the CPU     To be 100  sure you would need to find out the cost  in CPU cycles  for each instruction  which  unfortunately isn t readily available  you would have to look at the source for hotspot and then the CPU vendors specs for the time taken for each generated instruction    See the updated answer by Rotsor for a runtime analysis of the code

User · Answer

You don t need to use the short circuiting forms of the operators   return  a  amp  b     b  amp  c     c  amp  a    This performs the same number of logic operations as your version  however is completely branchless

User · Answer

I think the simplest solution is   return  a  amp  amp  b     c

User · Answer

I don t think I ve seen this solution yet   boolean atLeast int howMany  boolean   boolValues         check params for valid values    int counter   0    for  boolean b   boolValues        if  b          counter           if  counter    howMany            return true                      return false      Its advantage is that once it reaches the number that you re looking for  it breaks   So if this was  at least 2 out of this 1 000 000 values are true  where the first two are actually true  then it should go faster than some of the more  normal  solutions

User · Answer

return 1  lt  lt   a  lt  lt   b  lt  lt   c  gt   1  lt  lt  2

User · Answer

How about  a  b   amp  amp   a  c  -  Java  uses three comparisons instead of the OP s six   Wrong  I should have checked earlier

User · Answer

Let the three boolean values be A B and C      You can use a k-MAP and come with a boolean expression      In this case boolean expression will be A B C    C  or if  A  amp  amp   B    C       C       return true    else return false

[java] Check if at least two out of three booleans are true

Examples related to java

Examples related to boolean

Examples related to boolean-logic