2.02 Частично заполненный фрагмент таблицы

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 8 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z
for x in a:
    for y in a:
        for z in a:
            # Проверяем, что логическое выражение с текущим набором переменных дает истину
            if ((z == x) or ((z or y) <= x)) == False:
                # Если условие выполнено, выводим текущую комбинацию
                print(x, y, z)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z можно также организовать с помощью функции product из модуля itertools. Она генерирует все 8 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z")
# Генерируем все возможные комбинации из 0 и 1 длины 3 (для x,y,z)
for x, y, z in product([0, 1], repeat=3):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if ((z == x) or ((z or y) <= x)) == False:
        # Выводим подходящую комбинацию
        print(x, y, z)

После запуска программы получаем результат:

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

Аналитическое решение:

1. Рассмотрим первую строчку данного фрагмента. Предположим, что все переменные принимают значение , следовательно, а значит, Значит все переменные не могут быть равны . То есть во второй ячейке первой строки находится . Заметим, что для переменные должны принимать разные значения. Значит во второй ячейке первой строки находится одна из этих переменных. Предположим, что это место занимает Однако тогда импликация во второй скобке будет истинной, а значит, и вся дизъюнкция будет истинной. Следовательно, второй столбец занят переменной

2. Рассмотрим вторую строчку. Если третью ячейку этой строки занимает , то вторую ячейку должна занять , а значит, строчка совпадет со второй строкой. Значит третью ячейку занимает . Две другие ячейке не могут быть одновременно нулями, следовательно, вторую ячейку занимает . Предположим, что в первом столбце Но мы поняли, что и должны принимать равные значения (а в данном случае обе переменные равны ). Следовательно, первый столбец занимает а третий столбец занимает

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 8 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z
for x in a:
    for y in a:
        for z in a:
            # Проверяем, что логическое выражение с текущим набором переменных дает истину
            if ((y == z) or ((not y) and x)) == False:
                # Если условие выполнено, выводим текущую комбинацию
                print(x, y, z)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z можно также организовать с помощью функции product из модуля itertools. Она генерирует все 8 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z")
# Генерируем все возможные комбинации из 0 и 1 длины 3 (для x,y,z)
for x, y, z in product([0, 1], repeat=3):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if ((y == z) or ((not y) and x)) == False:
        # Выводим подходящую комбинацию
        print(x, y, z)

После запуска программы получаем результат:

Для начала заметим, что нет ни одной строки с тремя нулями, следовательно последняя строка из условия имеет вид 011. В строке с двумя единицами , значит на первом месте стоит . Единственный столбец, в котором можно расположить две единицы - это третий, можно однозначно определить, что переменная стоит на третьем месте. По остаточному принципу на втором месте расположена переменная .

Аналитическое решение:

1. Дизъюнкция ложна тогда, когда эквивалентность в первой скобке и конъюнкция во второй будут ложными. Эквивалентность будет ложной тогда, когда переменные будут иметь разные значения. Обратясь к фрагменту таблицы истинности, мы поймём, что эти переменные не могут занимать первый и второй столбец, второй и третий. Следовательно, под второй столбец отводится место для переменной .

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

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z, w (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 16 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z w")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z, w
for x in a:
    for y in a:
        for z in a:
            for w in a:
                # Проверяем, что логическое выражение с текущим набором переменных дает истину
                if ((not x and y) == z) and w:
                    # Если условие выполнено, выводим текущую комбинацию
                    print(x, y, z, w)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z, w можно также организовать с помощью функции product из модуля itertools. Она генерирует все 16 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z w")
# Генерируем все возможные комбинации из 0 и 1 длины 4 (для x,y,z,w)
for x, y, z, w in product([0, 1], repeat = 4):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if ((not x and y) == z) and w:
        # Выводим подходящую комбинацию
        print(x, y, z, w)

После запуска программы получаем результат:

Заметим, что третий столбец в условии пустой и в него мы можем подставить только w, так как в других столбцах есть 0. Во второй столбец подставим z, так как только в этом столбце три нуля. Теперь обратим внимание на вторую строчку, в ней w и z равны 1 и неизвестная переменная равна 0. В выводе нашей программы это вторая строка и в ней x равен 0, а y - 1. На четвёртый столбец подставляем x, а в первый подставляем y.

 

Аналитическое решение:

Для истинности выражения всегда должна быть равна 1. Это третий столбец.

Если , то для истинности выражения .

Если , то для истинности выражения .

Получаем случая:

Сравнивая две таблицы получаем что занимает последний столбец, занимает второй столбец, занимает первый столбец.

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z, w (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 16 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z w")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z, w
for x in a:
    for y in a:
        for z in a:
            for w in a:
                # Проверяем, что логическое выражение с текущим набором переменных дает истину
                if (((not(x)) <= y) and (y == (not(z))) and (not(w))) == True:
                    # Если условие выполнено, выводим текущую комбинацию
                    print(x, y, z, w)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z, w можно также организовать с помощью функции product из модуля itertools. Она генерирует все 16 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z w")
# Генерируем все возможные комбинации из 0 и 1 длины 4 (для x,y,z,w)
for x, y, z, w in product([0, 1], repeat = 4):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if (((not(x)) <= y) and (y == (not(z))) and (not(w))) == True:
        # Выводим подходящую комбинацию
        print(x, y, z, w)

Программа выведет следующую таблицу:

Сопоставим ее с таблицой из условия. Очевидно, что последний столбец это , так как это едиственный столбец, который не содержить 1. Предпоследний столбец это , так как это едиственный столбец, который содержит одну 1. Заметим, что при равном 1, 1 равна только переменная , благодоря этому определим, что второй столбец это , а первый это . Тогда ответ .

Решение аналитически:

Чтобы функция была истинной, всегда должна быть равна нулю. Единственный подходящий столбец — четвертый. Рассматривая вторую скобку можно понять что она будет истинна когда , тогда это не могут быть первый и второй, а также второй и третий столбец. Значит они занимают первый и третий столбец, а занимает второй.

Раз и строки не должны повторяться, то таблица примет следующий вид:

Так как у нас запрещён случай . Исходя из первой строки занимает первый столбец, а — третий.

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z, w (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 16 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z w")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z, w
for x in a:
    for y in a:
        for z in a:
            for w in a:
                # Проверяем, что логическое выражение с текущим набором переменных дает истину
                if (((x <= y) or (not (z <= w))) and ((w <= (not x)) or ((not y) <= z))) == False:
                    # Если условие выполнено, выводим текущую комбинацию
                    print(x, y, z, w)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z, w можно также организовать с помощью функции product из модуля itertools. Она генерирует все 16 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z w")
# Генерируем все возможные комбинации из 0 и 1 длины 4 (для x,y,z,w)
for x, y, z, w in product([0, 1], repeat = 4):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if (((x <= y) or (not (z <= w))) and ((w <= (not x)) or ((not y) <= z))) == False:
        # Выводим подходящую комбинацию
        print(x, y, z, w)

После запуска программы получаем результат:

Для начала заметим, что в результате мы не получили строк, состоящих только из нулей. Следовательно, первая строка из условия имеет вид 0001, и на четвёртом месте будет стоять переменная - она равна 1 в единственной строке с тремя нулями. В последней строке из условия не может быть 3 нуля, т.к. такие строки уже закончились, значит она будет иметь вид 0011. В строке с двумя единицами и . Одну из единиц в данной строке мы знаем, а значит на третьем месте будет расположена переменная . Вторая строка из условия будет иметь вид 0111, и в строке с тремя единицами . Однозначно можно сказать, что на первом месте находится переменная , и по остаточному принципу на втором месте - переменная .

Аналитическое решение:

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

Переменная не может быть нулем так как выражение в таком случае будет истинно. Значит это четвертый столбец. тогда весь столбец равен .

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

Во второй строке оставшийся пропуск заполняется единицей чтобы строки не повторялись.

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

Остался только второй столбец и переменная . Значит это второй столбец.

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z, w (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 16 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z w")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z, w
for x in a:
    for y in a:
        for z in a:
            for w in a:
                # Проверяем, что логическое выражение с текущим набором переменных дает истину
                if (((x <= z) and (z <= w)) or (y == (x or z))) == False:
                    # Если условие выполнено, выводим текущую комбинацию
                    print(x, y, z, w)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z, w можно также организовать с помощью функции product из модуля itertools. Она генерирует все 16 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z w")
# Генерируем все возможные комбинации из 0 и 1 длины 4 (для x,y,z,w)
for x, y, z, w in product([0, 1], repeat = 4):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if (((x <= z) and (z <= w)) or (y == (x or z))) == False:
        # Выводим подходящую комбинацию
        print(x, y, z, w)

После запуска программы получаем результат:

Заметим, что первый столбец - пустой, а наш столбец y полностью состоит из нулей и никакой в другой столбец y нельзя подставить, значит, подставляем y в первый столбец. Обратим внимание на 2-ую и 3-ую строчку, в них один и тот же столбец равен 1, при этом другая единица из этих строк перемещается. Такая ситуация есть только в одном столбце - столбце x. Поэтому подставляем столбец x в 4-ый столбец. Поскольку в столбце z только одна единица, то её мы подставляем в 3-ий столбец. Методом исключения понимаем, что для столбца w предназначен 2-ой столбец.

Аналитическое решение:

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

Чтобы правая скобка в дизъюнкции была ложна .

Если , то левая скобка становится . Она ложна при .

Если , то левая скобка становится . Она ложна при .

Если , то левая скобка ложна независимо от значения .

не могут быть одновременно значит они занимают второй и третий столбец, а — четвертый.

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

Когда , то выражение будет ложно (не считая случаи во второй и третьей строке) только при . Такой строки в таблице нет.

Когда , то выражение будет ложно при . Тогда занимает второй столбец, а — третий.

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z, w (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 16 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z w")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z, w
for x in a:
    for y in a:
        for z in a:
            for w in a:
                # Проверяем, что логическое выражение с текущим набором переменных дает истину
                if ((w and y) or ((x <= w) == (y <= z))) == False:
                    # Если условие выполнено, выводим текущую комбинацию
                    print(x, y, z, w)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z, w можно также организовать с помощью функции product из модуля itertools. Она генерирует все 16 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z w")
# Генерируем все возможные комбинации из 0 и 1 длины 4 (для x,y,z,w)
for x, y, z, w in product([0, 1], repeat = 4):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if ((w and y) or ((x <= w) == (y <= z))) == False:
        # Выводим подходящую комбинацию
        print(x, y, z, w)

После запуска программы получаем результат:

Заметим, что второй столбец - пустой, получается, подставляем, в тот столбец w. 4-ый столбец состоит полностью из единиц и у нас есть только один столбец с тремя единицами - это столбец x. Первая строчка из вывода программы - лишняя. И получаем, что столбец z содержит 2 единицы, а столбец y - одну. Подставляем z в первый столбец, а y - в третий столбец.

Аналитическое решение:

Нас не устраивает случай так как выражение будет истинно.

1) Если , то выражение примет вид . Оно будет ложно при и любом значении .

2) Если , то выражение будет истинно.

3) Если , то выражение примет вид . Оно будет ложно при .

У нас получилось 4 случая:

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

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 8 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z
for x in a:
    for y in a:
        for z in a:
            # Проверяем, что логическое выражение с текущим набором переменных дает истину
            if ((z == x) or ((not y) and x)) == 0:
                # Если условие выполнено, выводим текущую комбинацию
                print(x, y, z)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z можно также организовать с помощью функции product из модуля itertools. Она генерирует все 8 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z")
# Генерируем все возможные комбинации из 0 и 1 длины 3 (для x,y,z)
for x, y, z in product([0, 1], repeat=3):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if ((z == x) or ((not y) and x)) == 0:
        # Выводим подходящую комбинацию
        print(x, y, z)

После запуска программы получаем результат:

Для начала заметим, что только в одной строке есть 2 нуля, и в ней . Можно однозначно сказать, что расположена на третьем месте. Также стоит учесть, что только в одном столбце есть 2 нуля, а значит переменная стоит на первом месте, и переменная - на втором.

Аналитическое решение:

1. тогда, когда дизъюнкция ложна, а ложна она в случае, когда обе скобки ложны. Значит имеют разные значения. Предположим, что занимает третий столбец. Обратимся к первой строке. Но тогда конъюнкция во второй скобке истинна, что делает Если занимает третий столбец, то что также делает Следовательно, третий столбец занят переменной

2. Обратимся к третьей строке, в ней значит, Тогда

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

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 8 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z
for x in a:
    for y in a:
        for z in a:
            # Проверяем, что логическое выражение с текущим набором переменных дает истину
            if ((x <= (y and z)) or (z == x)) == 0:
                # Если условие выполнено, выводим текущую комбинацию
                print(x, y, z)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z можно также организовать с помощью функции product из модуля itertools. Она генерирует все 8 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z")
# Генерируем все возможные комбинации из 0 и 1 длины 3 (для x,y,z)
for x, y, z in product([0, 1], repeat=3):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if ((x <= (y and z)) or (z == x)) == 0:
        # Выводим подходящую комбинацию
        print(x, y, z)

Выведет таблицу:

Сопоставим две таблицы. Так как переменная два раза принимает значение , значит, — столбец, потому что в других столбцах нет места для двух единиц. Переменная — столбец, так как она два раза принимает значение , в других столбцах нет места для двух нулей. Остается, что — столбец.

Аналитическое решение:

1. Дизъюнкция ложна в том случае, когда обе скобки ложны. Рассмотрим первую скобку. Импликация будет ложна тогда, когда . Среди всех столбцов только во втором не присутствуют нули. Значит, второй столбец отводится под переменную , а также в ячейках в этом столбце находятся единицы.

2. Обратив внимание на вторую скобку, мы поймём, что принимают разные значения. Поэтому во второй строчке в третьей ячейке находится , а третий столбец занимает переменная . Из этого следует, что в первом столбце находится .

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 8 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z
for x in a:
    for y in a:
        for z in a:
            # Проверяем, что логическое выражение с текущим набором переменных дает истину
            if ((x <= (y and z)) or (z == x)) == 0:
                # Если условие выполнено, выводим текущую комбинацию
                print(x, y, z)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z можно также организовать с помощью функции product из модуля itertools. Она генерирует все 8 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z")
# Генерируем все возможные комбинации из 0 и 1 длины 3 (для x,y,z)
for x, y, z in product([0, 1], repeat=3):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if ((x <= (y and z)) or (z == x)) == 0:
        # Выводим подходящую комбинацию
        print(x, y, z)

Выведет таблицу:

Сопоставим две таблицы. Так как переменная два раза принимает значение , значит, — столбец, потому что в других столбцах нет места для двух единиц. Переменная — столбец, так как она два раза принимает значение , в других столбцах нет места для двух нулей. Остается, что — столбец.

Аналитическое решение:

Запишем таблицу истинности:

В таблице только две строки, в которых :

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

Программное решение:

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z, w (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 16 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z w")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z, w
for x in a:
    for y in a:
        for z in a:
            for w in a:
                # Проверяем, что логическое выражение с текущим набором переменных дает истину
                if x and (z and w or (not(z) and (y == w))):
                    # Если условие выполнено, выводим текущую комбинацию
                    print(x, y, z, w)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z, w можно также организовать с помощью функции product из модуля itertools. Она генерирует все 16 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z w")
# Генерируем все возможные комбинации из 0 и 1 длины 4 (для x,y,z,w)
for x, y, z, w in product([0, 1], repeat = 4):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if x and (z and w or (not(z) and (y == w))):
        # Выводим подходящую комбинацию
        print(x, y, z, w)

Результат работы программы:

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

Аналитическое решение:

Выпишем полную таблицу истинности и найдём все сочетания , , , при которых функция равняется нулю:

Дальнейшее аналитическое рассуждение аналогично рассуждению из решения №.

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z, w (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 16 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z w")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z, w
for x in a:
    for y in a:
        for z in a:
            for w in a:
                # Проверяем, что логическое выражение с текущим набором переменных дает истину
                if not(x) and (not(y) and not(z) or z and w):
                    # Если условие выполнено, выводим текущую комбинацию
                    print(x, y, z, w)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z, w можно также организовать с помощью функции product из модуля itertools. Она генерирует все 16 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z w")
# Генерируем все возможные комбинации из 0 и 1 длины 4 (для x,y,z,w)
for x, y, z, w in product([0, 1], repeat = 4):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if not(x) and (not(y) and not(z) or z and w):
        # Выводим подходящую комбинацию
        print(x, y, z, w)

Результат работы программы:

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

Аналитическое решение:

Выпишем полную таблицу истинности и найдём все сочетания , , , при которых функция равняется нулю:

Дальнейшее аналитическое рассуждение аналогично рассуждению из решения №.

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z, w (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 16 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z w")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z, w
for x in a:
    for y in a:
        for z in a:
            for w in a:
                # Проверяем, что логическое выражение с текущим набором переменных дает истину
                if (w and (x or (not y)) and (not (w == z))) == 1:
                    # Если условие выполнено, выводим текущую комбинацию
                    print(x, y, z, w)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z, w можно также организовать с помощью функции product из модуля itertools. Она генерирует все 16 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z w")
# Генерируем все возможные комбинации из 0 и 1 длины 4 (для x,y,z,w)
for x, y, z, w in product([0, 1], repeat = 4):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if (w and (x or (not y)) and (not (w == z))) == 1:
        # Выводим подходящую комбинацию
        print(x, y, z, w)

Выведем таблицу:

Сравним таблицы, можно понять, что — это столбец, т.к. там единички все. Дальше смотрим, что две единички только у — значит это последний столбец. Далее обратимся к последней строчке и сравним с выводом. В какой-то строке должно быть единички, но для формирования единичек нужна еще единичка в последней строке. Поэтому ставим ее. При этом можем сразу определить по этой единичке, что столбец — это . Методом исключения столбец — это .

Аналитическое решение:

Конъюнкция истинна только если все выражения, между которыми она стоит истинны.

Следовательно, всегда равен 1 и ему соответствует первый столбец.

Так как всегда равен 1, то должен быть всегда не равен ему и быть равен 0. Значит, эта переменная либо на 2, либо на 3 месте.

Истина в скобке будет, если либо , либо , либо .

Последний вариант возможен только в последней строке, значит - второй столбец, а так как дважды должен быть равен 0, третий столбец - , четвертый - .

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z, w (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 16 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z w")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z, w
for x in a:
    for y in a:
        for z in a:
            for w in a:
                # Проверяем, что логическое выражение с текущим набором переменных дает истину
                if (y or (x and w) or (w == z)) == 0:
                    # Если условие выполнено, выводим текущую комбинацию
                    print(x, y, z, w)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z, w можно также организовать с помощью функции product из модуля itertools. Она генерирует все 16 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z w")
# Генерируем все возможные комбинации из 0 и 1 длины 4 (для x,y,z,w)
for x, y, z, w in product([0, 1], repeat = 4):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if (y or (x and w) or (w == z)) == 0:
        # Выводим подходящую комбинацию
        print(x, y, z, w)

Получим табличку:

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

Аналитическое решение:

Выпишем полную таблицу истинности и найдём все сочетания , , , , при которых функция равняется нулю:

Дальнейшее аналитическое рассуждение аналогично рассуждению из решения 1.

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 8 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z
for x in a:
    for y in a:
        for z in a:
            # Проверяем, что логическое выражение с текущим набором переменных дает истину
            if ((x <= (not(y))) <= (not(z))) == (x and not(y)):
                # Если условие выполнено, выводим текущую комбинацию
                print(x, y, z)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z можно также организовать с помощью функции product из модуля itertools. Она генерирует все 8 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z")
# Генерируем все возможные комбинации из 0 и 1 длины 3 (для x,y,z)
for x, y, z in product([0, 1], repeat=3):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if ((x <= (not(y))) <= (not(z))) == (x and not(y)):
        # Выводим подходящую комбинацию
        print(x, y, z)

Программа выведет:

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

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 8 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z
for x in a:
    for y in a:
        for z in a:
            # Проверяем, что логическое выражение с текущим набором переменных дает истину
            if ((z == y) or (x and y)) == False:
                # Если условие выполнено, выводим текущую комбинацию
                print(x, y, z)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z можно также организовать с помощью функции product из модуля itertools. Она генерирует все 8 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z")
# Генерируем все возможные комбинации из 0 и 1 длины 3 (для x,y,z)
for x, y, z in product([0, 1], repeat=3):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if ((z == y) or (x and y)) == False:
        # Выводим подходящую комбинацию
        print(x, y, z)

После запуска программы получаем результат:

Для начала заметим, что есть только один столбец с двумя единицами. Можно однозначно сказать, что на первом месте находится переменаня . В строке, где , переменная , а значит на третьем месте находится , а на втором - .

Аналитическое решение:

1. Дизъюнкция ложна в случае, когда обе скобки будут ложными. А это значит, что будут иметь разные значения. Посмотрев на первую и третью строчки мы поймём, что эти переменные не могут занимать второй и третий столбец, первый и второй. Исходя из этого получим, что занимает второй столбец.

2. Посмотрим на третью строчку. В ней а это значит, что в этой строке, чтобы конъюнкция во второй скобке была ложной. Получается, что в третьей ячейке третьей строки находится . И этот столбец занят переменной . А первый столбец отводится под переменную .

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 8 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z
for x in a:
    for y in a:
        for z in a:
            # Проверяем, что логическое выражение с текущим набором переменных дает истину
            if (((not y) or (not z)) <= (z == x)) == False:
                # Если условие выполнено, выводим текущую комбинацию
                print(x, y, z)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z можно также организовать с помощью функции product из модуля itertools. Она генерирует все 8 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z")
# Генерируем все возможные комбинации из 0 и 1 длины 3 (для x,y,z)
for x, y, z in product([0, 1], repeat=3):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if (((not y) or (not z)) <= (z == x)) == False:
        # Выводим подходящую комбинацию
        print(x, y, z)

После запуска программы получаем результат:

Для начала заметим, что только в одном столбце присутствует две единицы, а значит можно однозначно определить, что на третьем месте. Строк с 3 единицами нет, поэтому первая строка будет иметь вид 011, и в строке с двумя единицами . Следовательно, стоит на первом месте, и – на втором.

Аналитическое решение:

Так как у нас импликация ложна, первая скобка должна равняться , вторая — . Значит, столбец не , так как, если столбец — , в первой строке = , что невозможно.

Допустим, столбец — , тогда и столбец — это и в любом порядке, что невозможно, так как они не могут оба одновременно принимать значение , потому что скобка не выполнится.

Допустим, — столбец, тогда — столбец, чтобы и не совпадали по значениям. Остается, что — столбец. Начнём заполнять таблицу: в и строке , так как в обеих строках, а скобка должна выполняться. Остается, что во строке, чтобы и не совпали, но тогда и строка совпадут, что невозможно.

Остается, что — столбец, а — столбец, так как столбец не может быть . И — столбец.

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z, w (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 16 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z w")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z, w
for x in a:
    for y in a:
        for z in a:
            for w in a:
                # Проверяем, что логическое выражение с текущим набором переменных дает истину
                if (((x == (not(y))) <= (y and not(z))) or (z and not(w))) == 0:
                    # Если условие выполнено, выводим текущую комбинацию
                    print(x, y, z, w)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z, w можно также организовать с помощью функции product из модуля itertools. Она генерирует все 16 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z w")
# Генерируем все возможные комбинации из 0 и 1 длины 4 (для x,y,z,w)
for x, y, z, w in product([0, 1], repeat = 4):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if (((x == (not(y))) <= (y and not(z))) or (z and not(w))) == 0:
        # Выводим подходящую комбинацию
        print(x, y, z, w)

Программа выведет:

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

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

Выпишем полную таблицу истинности по шагам:

Оставим только те строки, которые дают в результате 0:

Дальнейшее аналитическое рассуждение аналогично рассуждению из решения программой.

Решение программой с помощью циклов:

Напишем программу, которая проверяет все возможные комбинации значений переменных x, y, z, w (0 или 1) и выводит только те наборы, при которых заданное логическое выражение истинно. Используя вложенные циклы, код последовательно перебирает 16 вариантов, вычисляя для каждого результат выражения, и выводит на экран подходящие комбинации.

# Выводим заголовок для наглядности (значения переменных)
print("x y z w")
# Возможные значения переменных: 0 (False) или 1 (True)
a = (0, 1)

# Перебираем все возможные комбинации x, y, z, w
for x in a:
    for y in a:
        for z in a:
            for w in a:
                # Проверяем, что логическое выражение с текущим набором переменных дает истину
                if ((x == (not(y))) <= ((x and w) == z)) == 0:
                    # Если условие выполнено, выводим текущую комбинацию
                    print(x, y, z, w)

Решение программой с помощью itertools:

Перебор комбинаций x, y, z, w можно также организовать с помощью функции product из модуля itertools. Она генерирует все 16 вариантов комбинаций, а затем вычисляет значение выражения для каждого случая и выводит на экран подходящие комбинации.

# Импортируем функцию для декартова произведения
from itertools import product

# Выводим заголовок таблицы
print("x y z w")
# Генерируем все возможные комбинации из 0 и 1 длины 4 (для x,y,z,w)
for x, y, z, w in product([0, 1], repeat = 4):
    # Проверяем, что логическое выражение с текущим набором переменных дает истину
    if ((x == (not(y))) <= ((x and w) == z)) == 0:
        # Выводим подходящую комбинацию
        print(x, y, z, w)

Выведет таблицу:

Видим, что только раза равна , значит, второй столбец — это . Так как мы берем только строки где , значит, первый стобец — это , потому что только он раза равен при . столбец — это , так как только у нее есть строка, когда две переменные, кромее нее равны . Остается, что столбец это .

Аналитическое решение:

Выпишем полную таблицу истинности и найдём все сочетания , , , , при которых функция равняется нулю:

Дальнейшее аналитическое рассуждение аналогично рассуждению из решения №.

Решение 1

print(’x y z’)
for x in range(2):
    for y in range(2):
        for z in range(2):
            if not((z == x) or ((z or y) <= x)):
                print(x, y, z)

Решение 2

Для ложности данной функции дизъюнкция должна быть ложной, то есть обе скобки должны быть ложными. Рассмотрим, когда вторая скобка, то есть импликация, ложна. Это возможно только в случае, если и . То есть точно занимает первый столбец. Рассмотрим первую скобку, то есть . Она ложна, только если не равен . Поскольку всегда , то всегда . Значит, занимает второй столбец. Тогда оставшийся третий столбец занимает .