Logica per testare che 3 su 4 sono True

voglio ritornare True se e solo se 3 valori booleani su 4 sono veri.

Il più vicino che ho ottenuto è (x ^ y) ^ (a ^ b):

Cosa dovrei fare?

Suggerisco di scrivere il codice in un modo che indichi cosa intendi. Se vuoi che 3 valori siano veri, mi sembra naturale che il valore 3 appaia da qualche parte.

Ad esempio, in C++:

if ((int)a + (int)b + (int)c + (int)d == 3)
    ...

Questo è ben definito in C++: standard (§4.7/4)indica che la conversione boolin intdà i valori previsti 0 o 1.

In Java e C #, è possibile utilizzare il seguente costrutto:

if ((a?1:0) + (b?1:0) + (c?1:0) + (d?1:0) == 3)
    ...

# 1: Usando una ramificazione?: 3 o 4 operazioni

A ^ B ? C & D : ( C ^ D ) & A

# 2 Non ramificato, 7 operazioni

(A ^ B ^ C ^ D) & ((A & B) | (C & D))

Quando usavo per profilare tutto, ho scoperto che le soluzioni non ramificate erano un po 'più veloci operazione-per-operazione poiché la CPU poteva prevedere meglio il percorso del codice ed eseguire più operazioni in tandem. Tuttavia, nella dichiarazione di diramazione qui c'è circa il 50% di lavoro in meno.

Se questo fosse stato Python, avrei scritto

if [a, b, c, d].count(True) == 3:

O

if [a, b, c, d].count(False) == 1:

O

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

O

print [a, b, c, d].count(0) == 1

O

print [a, b, c, d].count(1) == 3

O

if a + b + c + d == 3:

O

if sum([a, b, c, d]) == 3:

Tutto questo funziona, poiché i booleani sono sottoclassi di numeri interi in Python.

if len(filter(bool, [a, b, c, d])) == 3:

O, ispirato a questo trucco pulito ,

data = iter([a, b, c, d])
if not all(data) and all(data):

Forma normale lunga ma molto semplice (disgiuntiva):

 (~a & b & c & d) | (a & ~b & c & d) | (a & b & ~c & d) | (a & b & c & ~d)

Può essere semplificato, ma ciò richiede una maggiore riflessione: P

Non sono sicuro che sia più semplice, ma forse.

((x xor y) and (a and b)) or ((x and y) and (a xor b))

Se vuoi usare questa logica in un linguaggio di programmazione, il mio suggerimento è

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

    return n1 + n2 + n3 + n4 == 3;
}

O se vuoi, puoi mettere tutti questi in una sola riga:

return (a ? 1 : 0) + (b ? 1 : 0) + (C ? 1 : 0) + (d ? 1 : 0) == 3;

Inoltre puoi generalizzare questo problema a n of m :

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

Questa risposta dipende dal sistema di rappresentazione, ma se 0 è l'unico valore interpretato come falso e not(false)restituisce sempre lo stesso valore numerico, allora not(a) + not(b) + not(c) + not(d) = not(0)dovrebbe fare il trucco.

Tenendo presente che SO se per domande di programmazione, piuttosto che semplici problemi logici, la risposta dipende ovviamente dalla scelta di un linguaggio di programmazione. Alcune lingue supportano funzionalità non comuni ad altre.

Ad esempio, in C ++ puoi testare le tue condizioni con:

(a + b + c + d) == 3

Questo dovrebbe essere il modo più veloce per eseguire il check in lingue che supportano la conversione automatica (di basso livello) da tipi booleani a interi. Ma ancora una volta, non esiste una risposta generale a questo problema.

Il meglio che posso fare è ((x ^ y) ^ (a ^ b)) && ((a || x) && (b || y))

((a xor b) xor (c xor d)) and ((a or b) and (c or d))

L'espressione del pugno cerca 1 o 3 truedi 4. Il secondo elimina 0 o 1 (e talvolta 2) truedi 4.

Java 8, filtra i valori falsi e conta i valori veri rimanenti:

public static long count(Boolean... values) {
    return Arrays.stream(values).filter(t -> t).count();
}

Quindi puoi usarlo come segue:

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

Si generalizza facilmente al controllo della presenza ndi moggetti veri.

Per verificare almeno nche tutto Booleansia vero, (n deve essere minore o uguale al numero totale di Boolean: p)

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

Modifica : dopo il commento di @ Cruncher

Per controllare 3 booleansu 4

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

Un altro :

((c & d) & (a ^ b)) | ((a & b) & (c ^ d))( Dettagli )

Ecco un modo per risolverlo in C # con LINQ:

bool threeTrue = new[] { a, b, x, y }.Count(x => x) == 3;

Questa è la funzione booleana simmetrica S₃(4). Una funzione booleana simmetrica è una funzione booleana che dipende solo dalla quantità di input impostati, ma non dipende da quali input siano. Knuth menziona funzioni di questo tipo nella sezione 7.1.2 del volume 4 di The Art of Computer Programming.

S₃(4) può essere calcolato con 7 operazioni come segue:

(x && y && (a || b)) ^ ((x || y) && a && b)

Knuth mostra che questo è ottimale, il che significa che non è possibile farlo in meno di 7 operazioni usando i normali operatori: &&, || , ^, <,e> .

Tuttavia, se si desidera utilizzare questo in una lingua che utilizza 1per true e 0per false, è anche possibile utilizzare l'aggiunta facilmente:

x + y + a + b == 3

che rende abbastanza chiara la tua intenzione.

(a && b && (c xor d)) || (c && d && (a xor b))

Da un puro punto di vista logico questo è quello che mi è venuta in mente.

Secondo il principio del buco del piccione, se esattamente 3 sono veri, allora aeb è vero, oppure c e d è vero. Quindi è solo una questione di anding ciascuno di quei casi con esattamente uno degli altri 2.

Tavolo della verità di Wolfram

Se usi uno strumento di visualizzazione logica come Karnaugh Maps, vedi che questo è un problema in cui non puoi evitare un termine logico completo se vuoi scriverlo in una riga if (...). Lopina lo ha già mostrato, non è possibile scriverlo più semplice. Puoi tenerne conto un po ', ma resterà difficile da leggere per te E per la macchina.

Le soluzioni di conteggio non sono male e mostrano ciò che stai veramente cercando. Come si esegue il conteggio in modo efficiente dipende dal linguaggio di programmazione. Le soluzioni array con Python o LinQ sono belle da vedere, ma attenzione, questo è LENTO. Wolf's (a + b + x + y) == 3 funzionerà bene e velocemente, ma solo se la tua lingua equivale a "vero" con 1. Se "vero" è rappresentato da -1, dovrai testare -3: )

Se la tua lingua usa veri booleani, potresti provare a programmarla esplicitamente (io uso! = Come test XOR):

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

"x! = y" funziona solo se x, y sono di tipo booleano. Se sono di qualche altro tipo in cui 0 è falso e tutto il resto è vero, ciò può fallire. Quindi usa un XOR booleano o ((bool) x! = (Bool) y) oppure scrivi "if (x) return (y == false) else return (y == true);", che è un po 'più lavorare per il computer.

Se il tuo linguaggio di programmazione fornisce l'operatore ternary?:, Puoi accorciarlo

if (a)
    return b ? (x != y) : (x && y);
else
    return b ? (x && y) : false;

che mantiene un po 'di leggibilità o lo taglia in modo aggressivo

return a ? (b ? (x != y) : (x && y)) : (b ? (x && y) : false);

Questo codice esegue esattamente tre test logici (stato di a, stato di b, confronto di xey) e dovrebbe essere più veloce della maggior parte delle altre risposte qui. Ma devi commentarlo o non lo capirai dopo 3 mesi :)

Ci sono molte buone risposte qui; ecco una formulazione alternativa che nessun altro ha ancora pubblicato:

 a ? (b ? (c ^ d) : (c && d)) : (b && c && d)

Simile alla prima risposta, ma Java puro:

int t(boolean b) {
    return (b) ? 1 : 0;
}

if (t(x) + t(y) + t(a) + t(b) == 3) return true;
return false;

Preferisco contarli come numeri interi perché rendono il codice più leggibile.

In Python , per vedere quanti di un iterabile di elementi sono True, usa sum(è abbastanza semplice):

Impostare

import itertools

arrays = list(itertools.product(*[[True, False]]*4))

Test effettivo

for array in arrays:
    print(array, sum(array)==3)

Produzione

(True, True, True, True) False
(True, True, True, False) True
(True, True, False, True) True
(True, True, False, False) False
(True, False, True, True) True
(True, False, True, False) False
(True, False, False, True) False
(True, False, False, False) False
(False, True, True, True) True
(False, True, True, False) False
(False, True, False, True) False
(False, True, False, False) False
(False, False, True, True) False
(False, False, True, False) False
(False, False, False, True) False
(False, False, False, False) False

Se stai cercando la soluzione on-the-paper (non programmabile), allora gli algoritmi K-maps e Quine-McCluskey sono ciò che stai cercando, ti aiutano a minimizzare la tua funzione booleana.

Nel tuo caso, il risultato è

y = (x̄3 ^ x2 ^ x1 ^ x0) ∨ (x3 ^ x̄2 ^ x1 ^ x0) ∨ (x3 ^ x2 ^ x̄1 ^ x0) ∨ (x3 ^ x2 ^ x1 ^ x̄0)

Se vuoi fare questa quantità programmata di variabili non fisse e una "soglia" personalizzata, allora semplicemente scorrere una lista di valori booleani e contare le occorrenze di "vero" è piuttosto semplice e diretto.

Voglio restituire vero se e solo se 3 valori booleani su 4 sono veri.

Dati i 4 valori booleani, a, b, x, y, questa attività si traduce nella seguente istruzione C:

return (a+b+x+y) == 3;

((a^b)^(x^y))&((a|b)&(x|y))

è quello che vuoi. Fondamentalmente ho preso il tuo codice e aggiunto il controllo se in realtà 3 sono veri e non 3 sono falsi.

Una domanda di programmazione senza una risposta che implichi la ricorsione? Inconcepibile!

Ci sono abbastanza risposte "esattamente 3 su 4 verità", ma ecco una versione generalizzata (Java) per "esattamente m di n verità" (altrimenti la ricorsione non ne vale davvero la pena) solo perché puoi:

public static boolean containsTrues(boolean[] someBooleans,
    int anIndex, int truesExpected, int truesFoundSoFar) {
  if (anIndex >= someBooleans.length) {
    return truesExpected == truesFoundSoFar; // reached end
  }
  int falsesExpected = someBooleans.length - truesExpected;
  boolean currentBoolean = someBooleans[anIndex];
  int truesFound = truesFoundSoFar + (currentBoolean ? 1 : 0);
  if (truesFound > truesExpected) {
    return false;
  }
  if (anIndex - truesFound > falsesExpected) {
    return false; // too many falses
  }
  return containsTrues(someBooleans, anIndex + 1, truesExpected,
      truesFound);
}

Questo potrebbe essere chiamato con qualcosa del tipo:

 boolean[] booleans = { true, false, true, true, false, true, true, false };
 containsTrues(booleans, 0, 5, 0);

che dovrebbe restituire true(perché 5 di 8 valori erano veri, come previsto). Non abbastanza soddisfatto delle parole "verità" e "falsità", ma non riesco a pensare a un nome migliore in questo momento .... Nota che la ricorsione si interrompe quando sono stati trovati troppi true o troppi falsevalori.

Poiché la leggibilità è una grande preoccupazione, è possibile utilizzare una chiamata di funzione descrittiva (avvolgendo una qualsiasi delle implementazioni suggerite). Se questo calcolo deve essere eseguito in più punti, una chiamata di funzione è il modo migliore per ottenere il riutilizzo e chiarisce esattamente cosa stai facendo.

bool exactly_three_true_from(bool cond1, bool cond2, bool cond3, bool cond4)
{
    //...
}

In PHP, rendendolo più dinamico (nel caso in cui cambi il numero di condizioni, ecc.):

$min = 6;
$total = 10;

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

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

echo $conditionMet ? "Passed" : "Failed";

(((a AND b) OR (x AND y)) AND ((a XOR b) OR (x XOR y)))

Mentre potrei dimostrare che questa è una buona soluzione, la risposta di Sam Hocevar è facile sia da scrivere che da capire in seguito. Nel mio libro questo lo rende migliore.

Ecco un po 'di codice c # che ho appena scritto perché mi hai ispirato:

Prende qualsiasi quantità di argomenti e ti dirà se n di essi sono veri.

    static bool boolTester(int n, params bool[] values)
    {
        int sum = 0;           

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

e lo chiami così:

        bool a = true;
        bool b = true;
        bool c = true;
        bool d = false;            

        bool test = false;
        test = boolTester(3, a, b, c, d);

Quindi ora puoi testare 7/9 o 15/100 come vuoi.