Минимальное количество проверок для проверки таблицы истинности

Question

У меня есть Java-программа, где я хочу проверить, если любое из 3 логических значений является ложным. Я хочу выяснить наименьшее выражение, которое я могу написать, чтобы сравнить с перестановками.

if(!(needsWork && (needsApproval || isAdmin) ))

Я думаю, этого достаточно, чтобы убедиться, что если любое из 3 логических значений имеет значение false, я хочу прекратить обработку. Тем не менее, у меня есть подозрение, что я что-то упустил.

Answer 1

Не будет ли if (!needsWork || !needsApproval || !isAdmin) работать? Java поддерживает оценку короткого замыкания.

Answer 2

Поскольку

`any 3 booleans are false` (i.e. `!a || !b || !c`)

и

`(! (needsWork && (needsApproval || isAdmin))` (i.e. (! (a && ( b || c))`

имеют разные таблицы истинности , уверены ли вы, что случаи, которые отличаютсяне имеет значения?

a b c   (!a || !b || !c)    (! (a && (b || c)))
T T T          F                    F          
T T F          T                    F
T F T          T                    F
T F F          T                    T
F T T          T                    T
F T F          T                    T
F F T          T                    T
F F F          T                    T

Преобразования

Я буду часто играть с логическими выражениями, чтобы попытаться уточнить или упростить их, и я используюэти логические преобразования, чтобы помочь мне:

// You can push (distribute) `!` into parenthesis if you reverse the `||` or `&&` operator inside:
! (a || b)             <=> (! a && ! b)
! (a || b || c || ...) <=> (! a && ! b && ! c && ...)

! (a && b)             <=> (! a || ! b)
! (a && b && c && ...) <=> (! a || ! b || ! c || ...)

// You can drop parens when the boolean operator outside the parens is the same as inside:
(a || (b || c || ...)) <=> (a || b || c)
(a && (b && c && ...)) <=> (a && b && c)

// You can push (distribute) a boolean op into parenthesis by applying it to each term inside:
(a || (b && c)         <=> ((a || b) && (a || c)
(a || (b && c && ...)  <=> ((a || b) && (a || c) && (a || ...) ...

(a && (b || c)         <=> ((a && b) || (a && c))
(a && (b || c || ...)  <=> ((a && b) || (a && c) || (a || ...) ...

// XOR means the term values have to be different:
(a ^ b)                <=> ((a && !b) || (!a && b))

// XOR means the same as OR unless both terms are true:
(a ^ b)                <=> ((a || b) && ! (a && b))

Конечно, есть много других, но это те, которые я использую чаще всего.Это может показаться сложным, но их легко узнать наизусть, как только вы начнете практиковать их.

В вашем случае, если вы хотите увидеть, для каких возможных эквивалентных утверждений:

(! (needsWork && (needsApproval || isAdmin) ))

вот несколько преобразований:

(! (needsWork && (needsApproval || isAdmin) ))   => [push the '!' through the `()`]
(! needsWork || ! (needsApproval || isAdmin) )   => [push the 2nd '!' through the `()`]
(! needsWork || (! needsApproval && ! isAdmin))

но я неувидеть любое реальное упрощение того, что у вас есть.

Конечно, если проверка того, что any of 3 booleans are false в порядке, то ваш выбор прост

(! needsWork || ! needsApproval || ! isAdmin) => [or pull the `!` outside the `()`]
(! (needsWork  && needsApproval && isAdmin))

Answer 3

if(!(needsWork & needsApproval & isAdmin))