Логика: есть (A &&! (B || C)) || (B || C) совпадает с (A || B || C)?

Я столкнулся с некоторым кодом obj-c, и мне интересно, есть ли способ его упростить:

#if ( A && !(B || C)) || ( B || C )

это то же самое, что и?

#if ( A || B || C )

Если нет, есть ли другой способ сформулировать его, что было бы легче читать?

[править] Я попробовал таблицу истинности, прежде чем задавать вопрос, но думал, что мне что-то не хватает, потому что я сомневался, что Foundation.framework/Foundation.h использует эту более сложную форму. Есть ли веская причина для этого?

Здесь исходный код (из Foundation.h):

#if (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) || (TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)

Ответ 1

Да. Как и другие, вы можете сказать правду. Правила De Morgan также могут помочь.

Однако, я думаю, лучший вариант - использовать карту Карно. Требуется несколько минут, чтобы узнать, но Карты Карно позволяют вам последовательно найти самое минимальное выражение для логической логики. Таблицы истинности могут проверить минимизацию, но они не могут дать вам.

Вот как я его понял:

Во-первых, расположение таблицы:

         AB
     00   01   11   10
  0|    |    |    |    |
C 1|    |    |    |    |

Теперь, учитывая ваше уравнение, B || C всегда вызывает правду:

         AB
     00   01   11   10
  0|    |  T |  T |    |
C 1|  T |  T |  T |  T |

Это оставляет только два случая. В любом случае правая сторона вычисляет значение false. Для 000 левая сторона также оценивает значение false (0 &! (Что угодно) является ложным). Для 100, 1 &! (0 ||| 0) имеет значение true. Таким образом, утверждение верно. Заполнение:

         AB
     00   01   11   10
  0|  F |  T |  T |  T |
C 1|  T |  T |  T |  T |

Теперь нам нужно только "покрыть" все истины. "C" будет охватывать нижний ряд. "B" будет охватывать средний квадрат (из четырех значений). Таким образом, "B || C" охватывает все, кроме верхнего правого квадрата. Теперь "A" будет охватывать правый квадрат с четырьмя квадратами. Это нормально, что это избыточно. Таким образом, "A || B || C" охватывает все истинные квадраты и опускает единственную ложную.

Ответ 2

Получите ручку + бумагу + попробуйте, есть только 8 возможных входов

Ответ 3

A | B | C | (B || C) | (!(B || C)) | (A && !(B || C)) | (A && (!(B || C)) || (B || C) | (A || B || C)
------------------------------------------------------------------------------------------------------
T | T | T |     T    |       F     |         F        |                 T             |         T      
T | T | F |     T    |       F     |         F        |                 T             |         T 
T | F | T |     T    |       F     |         F        |                 T             |         T 
T | F | F |     F    |       T     |         T        |                 T             |         T 
F | T | T |     T    |       F     |         F        |                 T             |         T 
F | T | F |     T    |       F     |         F        |                 T             |         T 
F | F | T |     T    |       F     |         F        |                 T             |         T 
F | F | F |     F    |       T     |         F        |                 F             |         F

Основываясь на последних двух столбцах, я бы сказал "да".

Ответ 4

Они одинаковы. Вы можете использовать Генератор таблиц истинности, чтобы проверить его. Оба эти выражения дают false только в одном случае, когда A, B и C являются false.

Ответ 5

Да, это одно и то же. Использование правил Де Моргана:

(A &! (B || C)) || (B || C) = (A & B && C) || (B || C). Таким образом, второе будет истинным, когда A = 1 и B, C = 0. Если это не так, вторая часть (B || C) будет истинна, когда B || C. Таким образом, он равен первому.

Ответ 6

Вы также можете сказать:

(A &! (B || C)) || (B || C) переписывает (A && W) || W (1)

(1) переписывает (A && W) || (A ||! A || W) (2)

(2) перезаписывает (A & W!) || (A || W) || (! A || W) (3)

(3) перезаписывает (A & W!) ||! (A & W!) || (A || W) (4)

(4) приводит к A || W, а затем A || B || С

Ответ 7

Да, два выражения эквивалентны. (Я просто написал несколько функций, чтобы проверить все восемь возможностей.)