부울 3 개 중 2 개 이상이 true인지 확인

한 면접관이 최근에이 질문을했습니다. 세 개의 부울 변수 a, b 및 c가 주어지면 세 개 중 두 개 이상이 참이면 true를 반환합니다.

내 해결책은 다음과 같습니다.

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 조건부 연산자? :

XOR을 사용하여 비교적 간단한 문제에 대답하기 위해 ...

return a ^ b ? c : a

문자 그대로 구현하지 않겠습니까? :)

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

C에서는 작성 a+b+c >= 2하거나 !!a+!!b+!!c >= 2매우 안전 할 수 있습니다.

에 대한 응답으로 TofuBeer 자바 바이트 코드의 비교, 여기에 간단한 성능 테스트는 다음과 같습니다

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

내 컴퓨터에서 다음을 인쇄합니다 (핫스팟 서버 VM (14.1-b02, 혼합 모드)으로 Intel Core 2 + sun java 1.6.0_15-b03에서 Ubuntu 실행) :

첫 번째와 두 번째 반복 :

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

(a + b + c> = 2) 사례에 대해 시간이 지남에 따라 성능 을 저하시키는 Java VM의 기능은 무엇입니까 ?

그리고 -clientVM 스위치로 java를 실행하면 어떻게됩니까?

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버전이 승리합니다.

OS X를 실행하는 최신 코드를 사용한 Tofubeer의 결과 :

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

Mac Java 1.6.0_26-b03-383-11A511을 사용한 Paul Wagland의 결과

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 Map 으로 해결할 수 있습니다 .

      | 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둘 다 true이거나 둘 다 false입니다. 둘 다 true이면 두 개의 실제 부울을 찾은 후 true를 반환 할 수 있습니다 (을 반환하여 a). 둘 다 거짓이면 참인 경우에도 두 개의 참 부울이있을 수 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);
}

터서?

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.

"개선 된"것은 상황에 따라 크게 다릅니다.

map / reduce를 사용하는 또 다른 구현이 있습니다. 이 규모도에 부울 수십억 ^© 분산 환경이다. MongoDB 사용하기 :

values부울 데이터베이스 작성 :

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

맵을 작성하고 기능을 줄입니다.

편집 : map / reduce가 일반 목록에 적용되는 것에 대한 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주기)을 알아야합니다. 불행히도 쉽게 사용할 수 없습니다 (핫스팟 소스를 확인한 다음 해당 시간 동안 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해시 값은 동일하게 사용할 수도 거짓 그래서에 대한 true 및 1237에 대한 1231으로 고정됩니다<= 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));
}

그러나 이러한 개선은 미미합니다.

나는 ( 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;
}

찾고자하는 숫자에 도달하면 중단됩니다. 따라서 처음 두 개가 실제로 참인 "이 1,000,000 개 값 중 적어도 2 개가 참"인 경우 좀 더 "정상적인"솔루션보다 빠릅니다.

bool을 정수로 변환하고 다음과 같은 쉬운 점검을 수행 할 수 있습니다.

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

그러나 아마도 사람들이 읽기 쉽고 3 개 이상으로 확장 할 수있게 만들 것입니다. 많은 프로그래머가 잊어 버린 것 같습니다.

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

JavaVM의 JRuby에서 실행할 수 있습니다. ;-)

그는 아마도 비트 비교 연산자 (일반적으로 복잡하지는 않지만 부울로 비트 연산자를 사용하는 것이 매우 이상합니다) 또는 int로 변환하고 합산하는 것과 같은 매우 둥근 것 같은 복잡한 것을 찾지 않을 것입니다.

이것을 해결하는 가장 직접적이고 자연스러운 방법은 다음과 같은 표현입니다.

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

원하는 경우 함수에 넣으십시오. 그러나 그렇게 복잡하지는 않습니다. 이 솔루션은 논리적으로 간결하고 효율적입니다.

C에서 :

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