Controlla se almeno due booleani su tre sono veri

Di recente un intervistatore mi ha posto questa domanda: date tre variabili booleane, a, b e c, ritornano vere se almeno due su tre sono vere.

La mia soluzione segue:

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

Ha detto che questo può essere ulteriormente migliorato, ma come?

Invece di scrivere:

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

Scrivi:

return someExpression;

Per quanto riguarda l'espressione stessa, qualcosa del genere:

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

o questo (qualunque sia più facile da capire):

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

Esegue il test ae besattamente una volta, e cal massimo una volta.

Riferimenti

• Operatore condizionale JLS 15.25? :

Solo per il gusto di usare XOR per rispondere a un problema relativamente semplice ...

return a ^ b ? c : a

Perché non implementarlo letteralmente? :)

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

In C potresti semplicemente scrivere a+b+c >= 2(o !!a+!!b+!!c >= 2essere molto al sicuro).

In risposta al confronto di TofuBeer sul bytecode java, ecco un semplice test delle prestazioni:

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

Questo stampa quanto segue sul mio computer (eseguendo Ubuntu su Intel Core 2 + sun java 1.6.0_15-b03 con HotSpot Server VM (14.1-b02, modalità mista)):

Prima e seconda iterazione:

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

Iterazioni successive:

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

Mi chiedo cosa potrebbe fare Java VM che degrada le prestazioni nel tempo per il caso (a + b + c> = 2).

Ed ecco cosa succede se eseguo java con uno -clientswitch 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

Mistero...

E se lo eseguo in GNU Java Interpreter , diventa quasi 100 volte più lento, ma la a&&b || b&&c || a&&cversione vince allora.

Risultati da Tofubeer con l'ultimo codice che esegue 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

Risultati di Paul Wagland con un 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

Questo tipo di domande può essere risolto con una mappa di Karnaugh :

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

da cui si deduce che è necessario un gruppo per la prima riga e due gruppi per la prima colonna, ottenendo la soluzione ottimale di poligenelubrificanti:

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

La leggibilità dovrebbe essere l'obiettivo. Qualcuno che legge il codice deve capire immediatamente il tuo intento. Quindi ecco la mia soluzione.

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

return howManyBooleansAreTrue >= 2;

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

Spiegazione:

Se a==b, allora entrambi sono veri o entrambi sono falsi. Se entrambi sono veri, abbiamo trovato i nostri due veri booleani e possiamo restituire vero (ritornando a). Se entrambi sono falsi, non possono esserci due veri booleani anche se cè vero, quindi restituiamo false (ritornando a). Questa è la (a==b) ? aparte. Che dire : c? Bene, se a==bè falso, allora esattamente uno ao bdeve essere vero, quindi abbiamo trovato il primo vero booleano, e l'unica cosa che rimane è se cè anche vero, quindi torniamo ccome risposta.

Non è necessario utilizzare le forme di corto circuito degli operatori.

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

Questo esegue lo stesso numero di operazioni logiche della tua versione, tuttavia è completamente senza rami.

Ecco un approccio generale basato sui test. Non "efficiente" come la maggior parte delle soluzioni finora offerte, ma chiaro, testato, funzionante e generalizzato.

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

Riassumilo. Si chiama algebra booleana per un motivo:

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

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

Se guardi le tabelle della verità lì, puoi vedere che la moltiplicazione è booleana e, e semplicemente l'aggiunta è xor.

Per rispondere alla tua domanda:

return (a + b + c) >= 2

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

Dipende davvero da cosa intendi per "migliorato":

Più chiaro?

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

Più generico?

boolean moreThanXTrue(int x, boolean[] bs)
{
    int count = 0;

    for(boolean b : bs)
    {
        count += b ? 1 : 0;

        if(count > x) return true;
    }

    return false;
}

Più scalabile?

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

Più veloce?

// Only profiling can answer this.

Quale è "migliorato" dipende fortemente dalla situazione.

Ecco un'altra implementazione che utilizza map / ridurre. Ciò si adatta bene a miliardi di booleani ^© in un ambiente distribuito. Utilizzare MongoDB:

Creazione di un database valuesdi booleani:

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

Creazione della mappa, riduzione delle funzioni:

Modifica : mi piace la risposta di CurtainDog sull'applicare / ridurre la mappa agli elenchi generici, quindi ecco una funzione della mappa che accetta un callback che determina se un valore deve essere contato o meno.

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

Esecuzione della mappa / riduzione:

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

Prendendo le risposte (finora) qui:

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

e eseguendoli attraverso il decompilatore (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
}

Puoi vedere che?: Quelli sono leggermente migliori della versione fissa del tuo originale. Quello che è il migliore è quello che evita del tutto la ramificazione. Ciò è positivo dal punto di vista del minor numero di istruzioni (nella maggior parte dei casi) e migliore per le parti di previsione del ramo della CPU, poiché un'ipotesi errata nella previsione del ramo può causare lo stallo della CPU.

Direi che quello più efficiente è quello di Moonshadow in generale. Utilizza in media il minor numero di istruzioni e riduce la possibilità di blocchi della pipeline nella CPU.

Per essere sicuri al 100% dovresti scoprire il costo (nei cicli della CPU) per ogni istruzione, che purtroppo non è prontamente disponibile (dovresti cercare l'origine dell'hotspot e quindi le specifiche dei fornitori di CPU per il tempo preso per ogni istruzione generata).

Vedere la risposta aggiornata di Rotsor per un'analisi di runtime del codice.

Un altro esempio di codice diretto:

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

Non è il codice più succinto, ovviamente.

appendice

Un'altra versione (leggermente ottimizzata) di questo:

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

Questo potrebbe essere leggermente più veloce, supponendo che il confronto con 0 userà un codice più veloce (o forse meno) rispetto al confronto con 2.

Ancora un altro modo per farlo, ma non molto buono:

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

I Booleanvalori di hashcode sono fissi a 1231 per true e 1237 per false, quindi avrebbe potuto essere utilizzato allo stesso modo<= 3699

La serie più ovvia di miglioramenti sono:

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

e poi

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

Ma questi miglioramenti sono minori.

Non mi piace il ternario ( return a ? (b || c) : (b && c);dalla risposta in alto) e non credo di aver visto nessuno menzionarlo. È scritto così:

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

In Clojure :

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

Uso:

(at-least 2 true false true)

Non credo di aver ancora visto questa soluzione:

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

Il suo vantaggio è che una volta raggiunto il numero che stai cercando, si rompe. Quindi se questo fosse "almeno 2 su 1.000.000 di valori sono veri" dove i primi due sono effettivamente veri, allora dovrebbe andare più veloce di alcune delle soluzioni più "normali".

Possiamo convertire i bool in numeri interi ed eseguire questo semplice controllo:

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

Poiché non è stato specificato come migliorare il codice, cercherò di migliorare il codice rendendolo più divertente. Ecco la mia soluzione:

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

Nel caso qualcuno si stia chiedendo se questo codice funziona, ecco una semplificazione usando la stessa logica:

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; 

}

Questo può essere ridotto ulteriormente a quanto segue:

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

Ma ora non è più divertente.

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

Troppi modi per farlo ...

Soluzione AC.

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

o potresti preferire:

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

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

Il modo più semplice (IMO) che non è confuso e facile da leggere:

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

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

Un'interpretazione letterale funzionerà in tutte le principali lingue:

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

Ma probabilmente renderei più facile la lettura delle persone ed espandibile a più di tre, qualcosa che sembra essere dimenticato da molti programmatori:

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

In aggiunta all'eccellente post di TofuBeer di TofuBeer, considera la risposta di pdox di @pdox:

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

Considera anche la sua versione disassemblata data da "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

La risposta di pdox viene compilata con un codice byte inferiore rispetto a una delle risposte precedenti. In che modo i suoi tempi di esecuzione si confrontano con gli altri?

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

Almeno sul mio computer, la risposta di pdox è solo leggermente più veloce della risposta di moonshadow di @moonshadow, rendendo pdox il più veloce in assoluto (sul mio laptop HP / Intel).

In Ruby:

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

Quale potrebbe essere eseguito in JRuby su JavaVM. ;-)

Probabilmente non è alla ricerca di qualcosa di contorto come operatori di confronto bit a bit (non normalmente contorto ma con valori booleani, è estremamente strano usare operatori bit a bit) o ​​qualcosa di molto rotondo come la conversione in int e la loro somma.

Il modo più diretto e naturale per risolverlo è con un'espressione come questa:

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

Mettilo in una funzione se preferisci, ma non è molto complicato. La soluzione è logicamente concisa ed efficiente.

In C:

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