ตรวจสอบว่าอย่างน้อยสองในสามบูลีนเป็นจริง

ผู้สัมภาษณ์เมื่อเร็ว ๆ นี้ได้ถามคำถามนี้กับฉัน: เมื่อกำหนดตัวแปรบูลีนสามตัวคือ a, b และ c ให้คืนค่าจริงถ้าอย่างน้อยสองจากสามตัวนั้นเป็นจริง

วิธีการแก้ปัญหาของฉันเป็นดังนี้:

boolean atLeastTwo(boolean a, boolean b, boolean c) {
    if ((a && b) || (b && c) || (a && c)) {
        return true;
    }
    else{
        return false;
    }
}

เขากล่าวว่าสิ่งนี้สามารถปรับปรุงได้มากขึ้น แต่อย่างไร

แทนที่จะเขียน:

if (someExpression) {
    return true;
} else {
    return false;
}

เขียน:

return someExpression;

สำหรับการแสดงออกนั้นบางอย่างเช่นนี้:

boolean atLeastTwo(boolean a, boolean b, boolean c) {
    return a ? (b || c) : (b && c);
}

หรือสิ่งนี้ (สิ่งที่คุณเข้าใจได้ง่ายกว่า):

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

มันทดสอบaและbว่าครั้งเดียวและอย่างcมากที่สุดครั้งเดียว

อ้างอิง

• JLS 15.25 ผู้ดำเนินการตามเงื่อนไข? :

เพียงเพื่อประโยชน์ของการใช้แฮคเกอร์เพื่อตอบปัญหาที่ค่อนข้างตรงไปตรงมา ...

return a ^ b ? c : a

ทำไมไม่ใช้มันอย่างแท้จริง? :)

(a?1:0)+(b?1:0)+(c?1:0) >= 2

ใน C คุณสามารถเขียนได้a+b+c >= 2(หรือ!!a+!!b+!!c >= 2ปลอดภัยมาก)

ในการตอบสนองต่อ เปรียบเทียบ TubeBeerของ java bytecode นี่คือการทดสอบประสิทธิภาพอย่างง่าย:

class Main
{
    static boolean majorityDEAD(boolean a,boolean b,boolean c)
    {
        return a;
    }

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

    static boolean majority2(boolean a,boolean b,boolean c)
    {
        return a ? b||c : b&&c;
    }

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

    static boolean majority4(boolean a,boolean b,boolean c)
    {
        return (a?1:0)+(b?1:0)+(c?1:0) >= 2;
    }

    static int loop1(boolean[] data, int i, int sz1, int sz2)
    {
        int sum = 0;
        for(int j=i;j<i+sz1;j++)
        {
            for(int k=j;k<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<i+sz1;j++)
        {
            for(int k=j;k<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<i+sz1;j++)
        {
            for(int k=j;k<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<i+sz1;j++)
        {
            for(int k=j;k<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<i+sz1;j++)
        {
            for(int k=j;k<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<data.length;i++)
            data[i] = r.nextInt(2) > 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<data.length-sz1-sz2;i++)
            sum += loop1(data, i, sz1, sz2);

        t1 = System.currentTimeMillis();

        for(int i=0;i<data.length-sz1-sz2;i++)
            sum += loop2(data, i, sz1, sz2);

        t2 = System.currentTimeMillis();

        for(int i=0;i<data.length-sz1-sz2;i++)
            sum += loop3(data, i, sz1, sz2);

        t3 = System.currentTimeMillis();

        for(int i=0;i<data.length-sz1-sz2;i++)
            sum += loop4(data, i, sz1, sz2);

        t4 = System.currentTimeMillis();

        for(int i=0;i<data.length-sz1-sz2;i++)
            sum += loopDEAD(data, i, sz1, sz2);

        tDEAD = System.currentTimeMillis();

        System.out.println("a&&b || b&&c || a&&c : " + (t1-t0) + " ms");
        System.out.println("   a ? b||c : b&&c   : " + (t2-t1) + " ms");
        System.out.println("   a&b | b&c | c&a   : " + (t3-t2) + " ms");
        System.out.println("   a + b + c >= 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);
        }
    }
}

สิ่งนี้จะพิมพ์สิ่งต่อไปนี้บนเครื่องของฉัน (ใช้งาน Ubuntu บน Intel Core 2 + sun java 1.6.0_15-b03 พร้อม HotSpot Server VM (14.1-b02, โหมดผสม)):

การวนซ้ำครั้งแรกและครั้งที่สอง:

a&&b || b&&c || a&&c : 1740 ms
   a ? b||c : b&&c   : 1690 ms
   a&b | b&c | c&a   : 835 ms
   a + b + c >= 2    : 348 ms
       DEAD          : 169 ms
sum: 1472612418

การทำซ้ำในภายหลัง:

a&&b || b&&c || a&&c : 1638 ms
   a ? b||c : b&&c   : 1612 ms
   a&b | b&c | c&a   : 779 ms
   a + b + c >= 2    : 905 ms
       DEAD          : 221 ms

ฉันสงสัยว่า Java VM สามารถทำอะไรได้บ้าง ประสิทธิภาพลดลงเมื่อเวลาผ่านไปสำหรับกรณี (a + b + c> = 2)

และนี่คือสิ่งที่จะเกิดขึ้นถ้าฉันเรียกใช้จาวาด้วย-clientสวิตช์ VM:

a&&b || b&&c || a&&c : 4034 ms
   a ? b||c : b&&c   : 2215 ms
   a&b | b&c | c&a   : 1347 ms
   a + b + c >= 2    : 6589 ms
       DEAD          : 1016 ms

ลึกลับ ...

และถ้าฉันใช้มันในGNU Java Interpreterมันจะช้าลงเกือบ 100 เท่า แต่a&&b || b&&c || a&&cเวอร์ชั่นจะชนะ

ผลลัพธ์จาก Tofubeer ด้วยรหัสล่าสุดที่ใช้ OS X:

a&&b || b&&c || a&&c : 1358 ms
   a ? b||c : b&&c   : 1187 ms
   a&b | b&c | c&a   : 410 ms
   a + b + c >= 2    : 602 ms
       DEAD          : 161 ms

ผลลัพธ์จาก Paul Wagland พร้อม Mac Java 1.6.0_26-b03-383-11A511

a&&b || b&&c || a&&c : 394 ms 
   a ? b||c : b&&c   : 435 ms
   a&b | b&c | c&a   : 420 ms
   a + b + c >= 2    : 640 ms
   a ^ b ? c : a     : 571 ms
   a != b ? c : a    : 487 ms
       DEAD          : 170 ms

คำถามประเภทนี้สามารถแก้ไขได้ด้วยแผนที่ Karnaugh :

      | C | !C
------|---|----
 A  B | 1 | 1 
 A !B | 1 | 0
!A !B | 0 | 0
!A  B | 1 | 0

จากที่คุณอนุมานว่าคุณต้องการกลุ่มสำหรับแถวแรกและสองกลุ่มสำหรับคอลัมน์แรกได้รับโซลูชันที่ดีที่สุดของ

(C && (A || B)) || (A && B)  <---- first row
       ^
       |
   first column without third case

การอ่านควรเป็นเป้าหมาย คนที่อ่านรหัสจะต้องเข้าใจเจตนาของคุณทันที นี่คือทางออกของฉัน

int howManyBooleansAreTrue =
      (a ? 1 : 0)
    + (b ? 1 : 0)
    + (c ? 1 : 0);

return howManyBooleansAreTrue >= 2;

return (a==b) ? a : c;

คำอธิบาย:

หากa==bทั้งสองเป็นจริงหรือทั้งสองเป็นเท็จ หากทั้งคู่เป็นจริงเราจะพบบูลีนที่แท้จริงของเราสองคนและสามารถกลับมาจริงaได้ หากทั้งสองเป็นเท็จมีไม่สามารถเป็นสอง booleans จริงแม้ว่าcจะเป็นจริงเพื่อให้เรากลับเท็จ (โดยกลับa) นั่นเป็น(a==b) ? aส่วนหนึ่ง เกี่ยวกับ: cอะไร ดีถ้าa==bเป็นเท็จแล้วว่าหนึ่งในaหรือbต้องเป็นจริงเพื่อให้เราได้พบความจริงบูลแรกและสิ่งเดียวที่เหลือว่าเรื่องคือถ้าcยังเป็นจริงเพื่อให้เรากลับมาcเป็นคำตอบ

คุณไม่จำเป็นต้องใช้รูปแบบการลัดวงจรของตัวดำเนินการ

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

วิธีนี้จะใช้การดำเนินการทางตรรกะในจำนวนเท่ากันกับเวอร์ชั่นของคุณ

นี่คือวิธีการทดสอบทั่วไป ไม่ได้ "มีประสิทธิภาพ" เหมือนโซลูชันส่วนใหญ่ที่นำเสนอ แต่ชัดเจนทดสอบทำงานและทั่วไป

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) >= 2;
    }

    private static int countBooleans(boolean... bs) {
        int count = 0;
        for (boolean b : bs)
            if (b)
                count++;
        return count;
    }
}

สรุปรวม มันถูกเรียกว่าพีชคณิตแบบบูลด้วยเหตุผล:

  0 x 0 = 0
  1 x 0 = 0
  1 x 1 = 1

  0 + 0 = 0
  1 + 0 = 1
  1 + 1 = 0 (+ carry)

ถ้าคุณดูที่ตารางความจริงตรงนั้นคุณจะเห็นว่าการคูณนั้นเป็นบูลีนและก็แค่เพิ่มก็คือ xor

ในการตอบคำถามของคุณ:

return (a + b + c) >= 2

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

มันขึ้นอยู่กับสิ่งที่คุณหมายถึงโดย "ปรับปรุง":

ชัดเจน?

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

Terser?

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.

สิ่งใดที่ "ปรับปรุง" ขึ้นอยู่กับสถานการณ์เป็นอย่างมาก

นี่คือการใช้งานอื่นโดยใช้แผนที่ / ลด สิ่งนี้ปรับขนาดได้ดีถึงพันล้าน booleans ^©ในสภาพแวดล้อมแบบกระจาย ใช้ MongoDB:

สร้างฐานข้อมูลvaluesของ booleans:

db.values.insert({value: true});
db.values.insert({value: false});
db.values.insert({value: true});

สร้างแผนที่ลดฟังก์ชั่น:

แก้ไข : ฉันชอบคำตอบของ CurtainDog เกี่ยวกับการมี map / ลดนำไปใช้กับรายการทั่วไปดังนั้นที่นี่จะมีฟังก์ชั่นแผนที่ซึ่งจะทำการโทรกลับที่กำหนดว่าควรนับจำนวนหรือไม่

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 < values.length; i++) {
        sum += values[i];
    }
    return sum;
}

ใช้แผนที่ / ลด:

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 >= count;
}

รับคำตอบ (จนถึงตอนนี้) ที่นี่:

public class X
{
    static boolean a(final boolean a, final boolean b, final boolean c)
    {
    return ((a && b) || (b && c) || (a && c));
    }

    static boolean b(final boolean a, final boolean b, final boolean c)
    {
    return a ? (b || c) : (b && c);
    }

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

    static boolean d(final boolean a, final boolean b, final boolean c)
    {
    return ((a?1:0)+(b?1:0)+(c?1:0) >= 2);
    }
}

และรันมันผ่านตัวถอดรหัส (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."<init>":()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
}

คุณจะเห็นว่า?: คนที่ดีกว่ารุ่นเดิมที่แก้ไขแล้วเล็กน้อย สิ่งที่ดีที่สุดคือสิ่งที่หลีกเลี่ยงการแตกแขนงโดยสิ้นเชิง นั่นเป็นสิ่งที่ดีจากมุมมองของคำสั่งที่น้อยลง (ในกรณีส่วนใหญ่) และดีกว่าสำหรับส่วนการทำนายสาขาของ CPU เนื่องจากการเดาผิดในการทำนายสาขาอาจทำให้ CPU หยุดทำงาน

ฉันจะบอกว่าคนที่มีประสิทธิภาพมากที่สุดคือคนที่มาจากดวงจันทร์โดยรวม จะใช้คำแนะนำน้อยที่สุดโดยเฉลี่ยและลดโอกาสในการขายแผงใน CPU

เพื่อให้แน่ใจว่า 100% คุณจะต้องค้นหาค่าใช้จ่าย (ในรอบ CPU) สำหรับแต่ละคำสั่งซึ่งน่าเสียดายที่ไม่มีให้ใช้งาน (คุณจะต้องดูแหล่งสัญญาณสำหรับฮอตสปอตแล้วจึงระบุผู้จำหน่ายซีพียูในเวลานั้น นำมาสำหรับการเรียนการสอนที่สร้างขึ้นแต่ละ)

ดูคำตอบล่าสุดโดย Rotsor สำหรับการวิเคราะห์รันไทม์ของรหัส

อีกตัวอย่างของรหัสโดยตรง:

int  n = 0;
if (a) n++;
if (b) n++;
if (c) n++;
return (n >= 2);

มันไม่ใช่รหัสรวบรัดที่สุดอย่างชัดเจน

ภาคผนวก

อีกรุ่น (ปรับให้เหมาะสมเล็กน้อย) ของสิ่งนี้:

int  n = -2;
if (a) n++;
if (b) n++;
if (c) n++;
return (n >= 0);

สิ่งนี้อาจทำงานได้เร็วขึ้นเล็กน้อยโดยสมมติว่าการเปรียบเทียบกับ 0 จะใช้โค้ดที่เร็วกว่า (หรืออาจน้อยกว่า) กว่าการเปรียบเทียบกับ 2

วิธีอื่นในการทำเช่นนี้ แต่ไม่ใช่วิธีที่ดีมาก:

return (Boolean.valueOf(a).hashCode() + Boolean.valueOf(b).hashCode() + Boolean.valueOf(c).hashCode()) < 3705);

Booleanค่าแฮชโค้ดได้รับการแก้ไขที่ 1231 สำหรับความจริงและ 1237 สำหรับดังนั้นเท็จอาจมีการใช้อย่างเท่าเทียมกัน<= 3699

ชุดการปรับปรุงที่ชัดเจนที่สุดคือ:

// There is no point in an else if you already returned.
boolean atLeastTwo(boolean a, boolean b, boolean c) {
    if ((a && b) || (b && c) || (a && c)) {
        return true;
    }
    return false;
}

แล้ว

// There is no point in an if(true) return true otherwise return false.
boolean atLeastTwo(boolean a, boolean b, boolean c) {
    return ((a && b) || (b && c) || (a && c));
}

แต่การปรับปรุงเหล่านั้นเล็กน้อย

ฉันไม่ชอบ ternary ( return a ? (b || c) : (b && c);จากคำตอบยอดนิยม) และฉันไม่คิดว่าฉันเคยเห็นใครพูดถึงมัน มันเขียนแบบนี้:

boolean atLeastTwo(boolean a, boolean b, boolean c) {
    if (a) {
        return b||c;
    } 
    else {
        return b&&C;
    }

ในClojure :

(defn at-least [n & bools]
  (>= (count (filter true? bools)) n)

การใช้งาน:

(at-least 2 true false true)

ฉันไม่คิดว่าฉันได้เห็นวิธีแก้ไขปัญหานี้แล้ว:

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;
}

ข้อได้เปรียบของมันคือเมื่อถึงจำนวนที่คุณต้องการ ดังนั้นหากนี่คือ "อย่างน้อย 2 จาก 1,000,000 ค่านี้เป็นจริง" ซึ่งทั้งสองอย่างแรกเป็นจริงแล้วมันควรจะเร็วกว่าโซลูชัน "ปกติ" บางตัว

เราสามารถแปลง bools เป็นจำนวนเต็มและทำการตรวจสอบง่าย ๆ นี้:

(int(a) + int(b) + int(c)) >= 2

เนื่องจากไม่ได้ระบุว่าควรปรับปรุงรหัสอย่างไรฉันจะพยายามปรับปรุงรหัสด้วยการทำให้สนุกยิ่งขึ้น นี่คือทางออกของฉัน:

boolean atLeastTwo(boolean t, boolean f, boolean True) {
    boolean False = True;
    if ((t || f) && (True || False)) 
        return "answer" != "42";
    if (t && f) 
        return !"France".contains("Paris");
    if (False == True) 
        return true == false;
    return Math.random() > 0.5;
}

ในกรณีที่ทุกคนสงสัยว่ารหัสนี้ใช้งานได้หรือไม่นี่คือการทำให้เข้าใจง่ายโดยใช้ตรรกะเดียวกัน:

boolean atLeastTwo(boolean a, boolean b, boolean c) {
    if ((a || b) && (c)) 
        return true;
    if (a && b) 
        return true;
    if (true) 
        return false;
    // The last line is a red herring, as it will never be reached:
    return Math.random() > 0.5; 

}

นี้สามารถต้มลงไปต่อไปนี้:

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

แต่ตอนนี้มันไม่ตลกอีกแล้ว

Function ReturnTrueIfTwoIsTrue(bool val1, val2, val3))
{
     return (System.Convert.ToInt16(val1) +
             System.Convert.ToInt16(val2) +
             System.Convert.ToInt16(val3)) > 1;
}

มีหลายวิธีที่จะทำ ...

สารละลาย AC

int two(int a, int b, int c) {
  return !a + !b + !c < 2;
}

หรือคุณอาจจะชอบ:

int two(int a, int b, int c) {
  return !!a + !!b + !!c >= 2;
}

return 1 << $a << $b << $c >= 1 << 2;

วิธีที่ง่ายที่สุด (IMO) ที่ไม่สับสนและอ่านง่าย:

// Three booleans, check if two or more are true

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

การตีความตามตัวอักษรจะใช้ได้กับทุกภาษาหลัก:

return (a ? 1:0) + (b ? 1:0) + (c ? 1:0) >= 2;

แต่ฉันอาจจะทำให้คนอ่านได้ง่ายขึ้นและขยายได้มากกว่าสาม - สิ่งที่ดูเหมือนจะถูกลืมโดยโปรแกรมเมอร์หลายคน:

boolean testBooleans(Array bools)
{
     int minTrue = ceil(bools.length * .5);
     int trueCount = 0;

     for(int i = 0; i < bools.length; i++)
     {
          if(bools[i])
          {
               trueCount++;
          }
     }
     return trueCount >= minTrue;
}

นอกเหนือจากโพสต์ที่ยอดเยี่ยมของ @TofuBeer TofuBeer ให้พิจารณาคำตอบของ @pdox pdox:

static boolean five(final boolean a, final boolean b, final boolean c)
{
    return a == b ? a : c;
}

พิจารณารุ่นที่ถอดประกอบตามที่กำหนดโดย "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 รวบรวมรหัสไบต์น้อยกว่าคำตอบก่อนหน้าใด ๆ เวลาดำเนินการเปรียบเทียบกับคนอื่น ๆ อย่างไร

one                5242 ms
two                6318 ms
three (moonshadow) 3806 ms
four               7192 ms
five  (pdox)       3650 ms

อย่างน้อยในคอมพิวเตอร์ของฉันคำตอบของ pdox นั้นเร็วกว่าคำตอบของ @moonshadow moonshadow เพียงเล็กน้อยทำให้ pdox นั้นเป็นภาพรวมที่เร็วที่สุด (บนแล็ปท็อป HP / Intel ของฉัน)

ในทับทิม:

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

ซึ่งสามารถเรียกใช้ใน JRuby บน JavaVM ;-)

เขาอาจจะไม่ได้มองหาอะไรที่ซับซ้อนเช่นผู้ให้บริการเปรียบเทียบระดับบิต (โดยปกติจะไม่ซับซ้อน แต่กับบูลีนมันแปลกมากที่จะใช้ตัวดำเนินการระดับบิต) หรือสิ่งที่เป็นวงเวียนมากเช่นการแปลงเป็น int และรวมพวกเขา

วิธีที่ตรงและเป็นธรรมชาติที่สุดในการแก้ปัญหานี้คือการแสดงออกเช่นนี้:

a ? (b || c): (b && c)

วางไว้ในฟังก์ชั่นหากคุณต้องการ แต่มันไม่ซับซ้อนมาก การแก้ปัญหามีความรัดกุมและมีเหตุผลเชิงตรรกะ

ใน C:

return !!a + !!b + !!c >= 2;