for a in range(1, 1000):
    c = 0
    for x in range(1, 10000):
       if (((x & 10 == 0 and x & 5 != 0) <= (x & 3 != 0)) or (x & a != 0)) == False:
            c = 1
            break
    if c == 0:
        print(a)
        break

for a in range(1, 1000):
    c = 0
    for x in range(1, 1000):
       if ((x & 15 != 0) <= ((x & 34 == 0) <= (x & a != 0))) == False:
            c = 1
            break
    if c == 0:
        print(a)
        break

for a in range(1, 300):
    # Переменная-флаг,
    # которой присваивается 1, если хотя бы одно выражение выдаёт ложь
    f = 0
    for x in range(1, 500):
             # Если выражение ложно(нам нужны только истинные),
             # то приостанавливаем цикл
       if (((x & 28 != 0) or (x & 45 != 0)) <= ((x & 17 == 0) <= (x & a != 0))) == False:
            f = 1
            break
    if f == 0:
        print(a)
        break

for a in range(1, 100):
    f = 0
    for x in range(1, 101):
        if ((((x & 13 != 0) or (x & a != 0)) <= (x & 13 != 0)) or ((x&a != 0) and (x & 39 == 0))) == False:
            f = 1
            break
    if f == 0:
        print(a)
#смотрим на последнее выведенное число, так как нам нужно наибольшее

for a in range(1, 1000):
    f = 0
    for x in range(1, 1001):
        if ((x & a != 0) <= ((x & 14 == 0) <= (x & 75 != 0))) == False:
            f = 1
            break
    if f == 0:
        print(a)
#смотрим на последнее выведенное число, так как нам нужно наибольшее

for A in range(1, 101):
    k = 0
    for x in range(1, 1000):
        if ((x & A == 0) and (x & 58 != 0) and (x & 22 == 0)) == 0:
            k += 1
    if k == 999:
        print(A)
        break

for a in range(1, 300):
    # Переменная-флаг,
    # которой присваивается 1, если хотя бы одно выражение выдаёт ложь
    f = 0
    for x in range(1, 500):
        # Если выражение ложно(нам нужны только истинные),
        # то приостанавливаем цикл
        if ((x & 45 != 0) <= ((x & 9 == 0) <= (x & a != 0))) == False:
            f = 1
            break
    # Так как ищем минимальное значение,
    # то сразу же после его нахождения прерываем цикл
    if f == 0:
        print(a)
        break

for a in range(1, 1500):
    # Переменная-флаг,
    # которой присваивается 1, если хотя бы одно выражение выдаёт ложь
    f = 0
    for x in range(1, 5000):
        # Если выражение ложно(нам нужны только истинные),
        # то приостанавливаем цикл
        if (((x & 937 != 0) or (x & 78 != 0)) <= (x & a != 0)) == False:
            f = 1
            break
    # Так как ищем минимальное значение,
    # то сразу же после его нахождения прерываем цикл
    if f == 0:
        print(a)
        break

for a in range(1,1000):
    f = 0
    for x in range(10000):
        if (((x & 45 != 0) or (x & 28 != 0) or (x & 56 != 0)) <= (x & a != 0)) == False:
            f = 1
            break
    if f == 0:
        print(a)
        break

for a in range(1, 100):
     # Переменная-флаг, по которой будем отслеживать наличие ложных выражений
     f = 0
     for x in range(1500):
         # Если нашлось такое выражение, то прекращаем перебор
         if (((x&15 != 0) and (x&64 != 0)) <= ((x&a != 0) and (x&15 != 0))) == False:
             f = 1
             break
     # Если ложных выражений не было, то выводим значение и прекращаем цикл,
     # так как нам нужно только минимальное значение
     if f == 0:
         print(a)
         break

for a in range(1, 100):
    # Переменная-флаг, по которой будем отслеживать наличие ложных выражений
    f = 0
    for x in range(1500):
        # Если нашлось такое выражение, то прекращаем перебор
        if ((x&a != 0) <= ((x&17 == 0) <= (x&33 != 0))) == False:
            f = 1
            break
    # Если ложных выражений не было, то выводим значение
    if f == 0:
        print(a)

for a in range(1, 100):
    # Переменная-флаг, по которой будем отслеживать наличие ложных выражений
    f = 0
    for x in range(1500):
        # Если нашлось такое выражение, то прекращаем перебор
        if (((x&38 != 0) or (x&45 != 0)) <= ((x&34 == 0) <= (x&a != 0))) == False:
            f = 1
            break
    # Если ложных выражений не было, то выводим значение и прекращаем цикл,
    # так как нам нужно только минимальное значение
    if f == 0:
        print(a)
        break

Решение руками:

Упростим выражение, раскрыв импликацию:

Преобразуем выражение по законам алгебры логики:

Таким образом из выражения видно, что левое выражение должно выполняться, когда правое не выполняется, следовательно .

Решение программой:

for a in range(1, 1000):
    flag = True
    for x in range(1, 1000):
        if (((x & 13 != 0) or (x & 13 == 0)) <= ((x & a != 0) or (x & 39 == 0))) == False:
            flag = False
            break
    if flag:
        print(a)
        break

Решение руками:

Преобразуем выражение по законам алгебры логики:

Заметим, что первое слагаемое логической суммы является импликацией , которая не является истинной для всех . Тогда необходимо и достаточно, чтобы второе слагаемое логической суммы было тождественно истинным.

Итак, импликация должна быть тождественно истиной. Запишем число 10 в двоичной системе счисления:

Единичные биты, стоящие в правой части, должны являться единичными битами левой. Поэтому в правой части единичными битами независимо друг от друга могут быть (а могут и не быть) только первый и третий биты (считая справа налево, начиная с нуля). Поскольку искомое А – наибольшее натуральное число, все биты, которые могут быть единичными будут единичными.

Тем самым, наибольшее .

Решение программой:

for a in range(1, 1000):
    flag = True
    for x in range(1, 1000):
        if ((x & 10 != 0) or (x & 39 == 0) or (x & a == 0)) == False:
            flag = False
            break
    if flag:
        print(a)

Преобразуем выражение к виду с помощью законов де Моргана:

Для того, чтобы выражение вида являлось истинным, единичные биты, стоящие в правой части, должны являться единичными битами левой.

Запишем числа 10 и 5 в двоичной системе счисления:

Значит, обязательно должно содержать в себе единицу во всех разрядах. Так как ищем наибольшее , наш ответ .

def f(a):
    # если отрцание формулы возвращает истину,
    # то сама формула возвращает ложь
    for x in range(1000):
        if not((x & a != 0) <= ((x & 14 == 0) <= (x & 3 != 0))):
            return False
    return True

for a in range(1000):
    if f(a):
        print(a)

Введем обозначение: Тогда выражение имеет вид

Так как

Помним, что Тогда наше выражение имеет вид Т.к. это то же самое, что

Воспользуемся тем, что Наше выражение тогда имеет вид

Знаем, что Тогда получаем

Мы хотим, чтобы данное выражение всегда было равно 1. Для этого нужно, чтобы или или

Помним, что импликация истинна, если на тех местах, где в двоичной записи числа справа стоят единицы, стоят единицы и в двоичной записи числа слева, то есть наименьшее неотрицательное целое — это и есть число справа, то есть 17 в первом случае и 57 во втором. Мы ищем наименьшее число — то есть нам подходит 17.

Введем обозначение: Тогда выражение имеет вид

Используя, что получим:

Теперь снова воспользуемся этим правилом, только в обратную сторону. Получим

Так как наше выражение имеет вид

Правую часть можем сразу вычислить, поразрядно сложив в двоичной системе счисления. Это

Теперь рассмотрим левую часть. Знаем, что, чтобы импликация была истинной, нам нужно, чтобы на всех местах, где в двоичной записи правого выражения стоит единица стояла и в записи выражения слева. Для удобства запишем в столбик (пока не знаем, чему равно) и а под чертой —

\(\)

r
11101
111111

\(\)

Итак, на тех местах, где в числе под чертой стоят единицы, единицы должны стоять и в поразрядном сложении и — верхних двух чисел.

Таким образом, на месте второго с конца бита числа должна стоять — а на остальных местах неважно, что: благодаря 29 на этих местах и так будут стоять 1.

Так как мы ищем наименьшее неотрицательное целое на тех местах, на каких можем, мы хотим ставить Значит, имеет вид

Обозначим Перепишем: для любых

Воспользуемся тем, что Тогда Теперь воспользуемся тем же в обратную сторону: соберем импликацию. Получим

Помним, что Тогда

Переведем в двоичную систему счисления известные числа: 17 = 10001, 25 = 11001.

\(\)

r _& 10001;
;

\(\)

Известно, что, чтобы данная импликация была равна 1, на тех местах, где в двоичной записи 25 стоят единички, в двоичной записи должны тоже стоять единички.

Мы ищем наименьшее неотрицательное целое число Значит, где вместо звездочек можно ставить нули, — будем ставить. Двигаемся справа налево. На место первой звездочки можно поставить 0 — единичка уже есть в записи числа 17. На втором месте все равно, что ставить, — в записи 25 на этом месте 0. Ставим 0. Аналогично ставим на третье место. Теперь посмотрим на четвертое: в записи 25 — стоит 1, а вот в записи 17 — 0. Значит, на четвертом месте в числе должна быть единичка. Аналогично заканчиваем ставить знаки. Никаких лишних разрядов впереди числа добавлять не будем — мы ищем наименьшее.

Итак, получили 1000. Это число в двоичной системе счисления. В десятичной — 8.

for a in range(0, 1000):
    flag = True
    for x in range(0, 1000):
        if ((x & a != 0) <= (((x & 17 == 0) and (x & 5 == 0)) <= (x & 3 != 0))) == False:
            flag = False
            break
    if flag:
        print(a)