15.03 Неравенства

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

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

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

Правая часть

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

Левая часть

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

Так как необходимо, чтобы обе части давали истину и при этом A было максимальным, ответ .

Идея решения:

Перебираем все возможные значения от до . Для каждого с помощью вложенных циклов for перебираем все неотрицательные значения и (в коде — от 0 до 299). Для каждой пары проверяем логическое выражение

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

# Функция проверки выражения для фиксированного A, x и y
def f(A, x, y):
    return ((x <= 9) <= (x * x <= A)) and ((y * y <= A) <= (y <= 9))

# Переменная для хранения наибольшего подходящего A
ma = 0

# Перебор всех возможных значений A
for A in range(150):
    # Считаем, что A подходит, пока не доказано обратное
    flag = True

    # Перебираем все возможные x
    for x in range(300):
        # Перебираем все возможные y
        for y in range(300):
            # Если условие не выполняется — A не подходит
            if not f(A, x, y):
                flag = False
                break

    # Если A подошёл — сохраняем его
    if flag:
        ma = A

# Выводим наибольший подходящий A
print(ma)

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

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

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

Правая часть

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

Левая часть

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

Так как необходимо, чтобы обе части давали истину и при этом A было максимальным, ответ .

Идея решения:

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

Если хотя бы для одной пары выражение ложно, данный исключаем. Если же для всех перебранных пар выражение истинно, данный подходит. Так как требуется наибольшее , перебор идёт в обратном порядке, и первый подходящий будет ответом.

# Функция проверки выражения для фиксированного A, x и y
def f(x, y, a):
    return ((x <= 9) <= (x * x <= a)) and ((y * y <= a) <= (y <= 10))

# Перебор A от 300 до 0 для поиска наибольшего подходящего
for a in range(300, -1, -1):
    # Флаг: 0 - условие не выполнилось ни разу,
    1 - условие хотя бы раз не выполнялось
    fl = 0

    # Перебор x
    for x in range(300):
        # Перебор y
        for y in range(300):
            # Если выражение не выполняется, ставим флаг и выходим из цикла
            if not f(x, y, a):
                fl = 1
                break
        if fl:
            break

    # Если условие не нарушилось ни разу для всех x и y — A подходит
    if not fl:
        print(a)  # выводим наибольшее подходящее A
        break

Решение 1 (руками)

Чтобы дизъюнкция была истинной при любом неотрицательном целом значении и рассмотрим случай, когда и

Это эквивалентно следующей системе:

Самое сильное ограничение для в системе будет при наименьших и т. е. при и соответственно.

Подставим: откуда Наибольшее значение

Идея решения:

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

Если найдётся хотя бы одна пара , для которой выражение ложно, то данный не подходит. Если же для всех перебранных пар выражение истинно, то этот подходит. Так как требуется найти наибольшее подходящее значение , достаточно пройти все значения, а в переменной ans хранить последний найденный вариант.

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

# Функция проверки логического выражения
def f(x, y, A):
    return (x + 3*y > A) or (x < 18) or (y < 33)

# Перебор значений A
for A in range(1, 200):
    flag = True  # флаг, что A подходит

    # Перебор значений x
    for x in range(1, 200):
        # Перебор значений y
        for y in range(1, 200):
            # Если выражение не выполняется для какой-то пары
            if not f(x, y, A):
                flag = False  # A не подходит
                break
        if not flag:
            break

    # Если для всех x и y выражение истинно
    if flag:
        ans = A  # сохраняем подходящее значение A

# Печатаем наибольшее подходящее A
print(ans)

Чтобы дизъюнкция была ложной при любом неотрицательном целом значении и рассмотрим случай, когда и

Это эквивалентно следующей системе:

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

Подставим: откуда Значит, наименьшее значение A, когда выражение будет тождественно ложным — это 151.

Идея решения:

Ищем наименьшее неотрицательное , при котором формула

ложна при фиксированных значениях и . Перебираем значения по возрастанию (например, от до ) с помощью цикла for. Для каждого подставляем , и вычисляем логическое выражение. Если оно ложно, значит найдено минимальное подходящее ; выводим его и завершаем перебор.

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

# перебираем A по возрастанию
for a in range(1000):
    # проверяем выражение при x=20, y=18 для текущего a
    # если выражение ложно, условие задачи выполнено
    if ((3*20 + 5*18 >= a) or (20 < 20) or (18 <= 17)) == False:
        # выводим найденное минимальное A
        print(a)
        # завершаем поиск, так как A минимально
        break

Решение 1 (ручками):

Система для врагов:

Самое сильное ограничение для в системе будет при наименьших и т. е. при и соответственно.

Тогда для друзей имеем: откуда Наибольшее значение

Идея решения:

Нужно найти наибольшее целое , при котором выражение

тождественно истинно для всех неотрицательных . В программе перебираем значения в убывающем порядке (от до ), чтобы сразу получить наибольшее подходящее. Для каждого двумя вложенными циклами for перебираем и в диапазоне (от 0 до 99) и проверяем логическое выражение. Если найдётся хотя бы одна пара , для которой выражение не выполняется (ложно), текущий не подходит. Если после всех проверок выражение оказалось истинным для всех , печатаем этот как ответ и завершаем перебор.

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

# перебираем A по убыванию, чтобы сразу найти наибольшее подходящее
for a in range(100, 0, -1):
    # считаем, что для текущего A выражение выполняется для всех x,y
    flag = True
    # перебираем неотрицательные x
    for x in range(100):
        # перебираем неотрицательные y
        for y in range(100):
            # проверяем выражение
            if ((x + 1 / 6 * y > a) or (x < 18 / 27) or (y < 5)) == 0:
                # нашли пару, где выражение не выполняется, значит, A не подходит
                flag = False
    # если ни одной "плохой" пары не было, текущий A подходит
    if flag:
        # выводим наибольшее подходящее A
        print(a)
        # завершаем поиск
        break

Решение 1 (руками)

Чтобы дизъюнкция была истинной при любом неотрицательном целом значении и рассмотрим случай, когда и

Это эквивалентно следующей системе:

Самое сильное ограничение для в системе будет при наибольших и т. е. при и соответственно.

Подставим: откуда Наименьшее значение

Идея решения:

Перебираем целые неотрицательные значения по возрастанию (в коде — (от 0 до 99). Для каждого вложенными циклами for перебираем положительные целые (в коде — от до ) и проверяем выполнение выражения

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

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

# функция проверяет, что для данного a выражение истинно при всех x,y
def f(a):
    # перебираем положительные x
    for x in range(1, 1000):
        # перебираем положительные y
        for y in range(1, 1000):
            # если выражение ложно для текущих x,y — a не подходит
            if not ((x + 6 * y < a) or (x > 25) or (y >= 12)):
                return False
    # ни одной "плохой" пары не найдено — a подходит
    return True

# перебираем возможные значения A по возрастанию
for a in range(100):
    # если для текущего A выражение истинно для всех x,y
    if f(a):
        # выводим наименьшее подходящее A
        print(a)
        # завершаем поиск
        break

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

Чтобы дизъюнкция была истинной при любом неотрицательном целом значении и рассмотрим случай, когда и

Это эквивалентно следующей системе:

Самое сильное ограничение для в системе будет при наименьших и т. е. при 21 и 10 соответственно.

Подставим: , откуда . Наибольшее значение

Идея решения:

Перебираем целые неотрицательные значения от до . Для каждого вложенными циклами for перебираем положительные целые (в коде — от до ) и проверяем выполнение выражения

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

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

# функция проверяет выполнение выражения для x,y,a
def f(x, y, A):
    return (3*x + 9*y >= A) or (not(x > 20)) or (y < 10)

ans = 0
# перебираем возможные значения A от 1 до 299
for A in range(1, 300):
    flag = True
    # перебираем положительные x
    for x in range(1, 200):
        # перебираем положительные y
        for y in range(1, 200):
            # если выражение ложно хотя бы для одной пары (x,y) — A не подходит
            if not f(x, y, A):
                flag = False
                break
        if not flag:
            break
    # если текущее A подходит — запоминаем его
    if flag:
        ans = A

# выводим наибольшее подходящее A
print(ans)

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

Инвертируем известную часть:

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

Чтобы выполнялось , нужно брать значения кратные 5, т.к. кратно 5, и кратно 5.

Нам подходят следующие пары переменных:

Пара уже не будет подходить, т.к. условие не выполняется.

Следовательно, берём пару с наименьшим : .

При , наибольшее равно 13.

Идея решения:

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

Если найдётся хотя бы одна пара , для которой выражение не выполняется (ложно), текущее отбрасываем. Если же для всех перебранных пар выражение истинно, считается подходящим и выводится как наибольшее.

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

# перебор возможных значений A от 100 до 2 по убыванию
for a in range(100, 1, -1):  # перебор от 100 до 2 по убыванию
    flag = True  # предполагаем, что текущее A подходит
    # перебор x от 0 до 999
    for x in range(1000):
        # перебор y от 0 до 999
        for y in range(1000):
            # если выражение ложно для текущих x,y — A не подходит
            if ((5*x + 2*y != 85) or (a <= x) or (x <= y)) == False:
                flag = False
                # если нашли "плохую" пару, прекращаем перебор y
                break
        # прекращаем перебор x
        if flag == False:
            break
    # если выражение истинно для всех x,y, выводим A и завершаем поиск
    if flag == True:
        print(a)
        break

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

Чтобы дизъюнкция была ложной при некотором неотрицательном целом значении и рассмотрим случай, когда и

Это эквивалентно следующей системе:

Определим подходящие пары значений , которые удовлетворяют первым 2 условиям системы:

Так как а оба числа – натуральные, то подойдет только пара

Значит, должно выполняться неравенство откуда наименьшее значение —

Идея решения:

Перебираем целые неотрицательные значения по возрастанию (в коде — от 0 до 999). Для каждого вложенными циклами for перебираем все натуральные числа и (в коде — от 1 до 999) и проверяем выражение

Если для какой-либо пары выражение ложно, текущий подходит, так как условие задачи требует, чтобы формула была ложна хотя бы для одного набора значений. Первое найденное такое и будет наименьшим подходящим.

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

# перебор возможных значений A от 0 до 999
for a in range(0, 1000):  # перебираем неотрицательные A
    c = 0  # переменная-флаг, показывает найдено ли "ложное" значение
    # перебор натуральных x
    for x in range(1, 1000):
        # перебор натуральных y
        for y in range(1, 1000):
            # вычисляем логическое выражение
            F = (3*x + 4*y != 52) or (a < x) or (y <= x)
            # если выражение ложно, A подходит
            if F == False:
                c = 1  # меняем значение флага
                break
        # если флаг изменился, прекращаем оба цикла
        if c == 1:
            break
    # если найдено хотя бы одно ложное выражение, выводим A и прекращаем поиск
    if c == 1:
        print(a)
        break

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

Чтобы дизъюнкция была ложной при некотором неотрицательном целом значении и рассмотрим случай, когда и

Это эквивалентно следующей системе:

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

Подставим: откуда Значит, наименьшее значение A, когда выражение будет тождественно ложным — это 147.

Идея решения:

Перебираем целые неотрицательные значения по возрастанию (в коде — от 0 до 999). Для каждого вложенными циклами for перебираем все неотрицательные целые числа и (в коде — от 0 до 999) и проверяем выражение

Если найдётся хотя бы одна пара , для которой выражение ложно, текущий подходит. Первое найденное такое и будет наименьшим подходящим.

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

# перебор возможных значений A от 0 до 999
for a in range(0, 1000):  # перебираем неотрицательные A
    c = 0  # переменная-флаг, показывает найдено ли "ложное" значение
    # перебор неотрицательных x
    for x in range(0, 1000):
        # перебор неотрицательных y
        for y in range(0, 1000):
            # вычисляем логическое выражение
            F = (3*x + y >= a) or (x < 30) or (y <= 55)
            # если выражение ложно, A подходит
            if F == False:
                c = 1  # меняем значение флага
                break
        # если флаг изменился, прекращаем оба цикла
        if c == 1:
            break
    # если найдено хотя бы одно ложное выражение, выводим A и прекращаем поиск
    if c == 1:
        print(a)
        break

Решение 1 (ручками)

Чтобы дизъюнкция была истинной при любом неотрицательном целом значении и рассмотрим случай, когда и

Это эквивалентно следующей системе:

Самое сильное ограничение для в системе будет при наименьших и т. е. при и соответственно.

Подставим: откуда Наибольшее значение

Идея решения:

Перебираем целые неотрицательные значения по убыванию (в коде — от 1000 до 1). Для каждого вложенными циклами for перебираем все неотрицательные целые числа и (в коде — от 0 до 999) и проверяем выражение

Если найдётся хотя бы одна пара , для которой выражение ложно, текущее не подходит. Первое , для которого выражение истинно для всех перебранных , и будет искомым наибольшим.

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

# функция проверяет, что для данного A выражение истинно для всех x,y
def f(a):
    # перебираем неотрицательные x
    for x in range(1000):
        # перебираем неотрицательные y
        for y in range(1000):
            # если выражение ложно для текущих x,y — a не подходит
            if ((6 * x + 3 * y >= a) or (x <= 40) or (y < 57))==0:
                return False
    # ни одной "плохой" пары не найдено — a подходит
    return True

# перебираем возможные значения A по убыванию
for a in range(1000, 1, -1):
    # если для текущего A выражение истинно для всех x,y
    if f(a):
        # выводим наибольшее подходящее A
        print(a)
        # завершаем поиск
        break

Решение 1 (ручками)

Инвертируем известную часть:

Чтобы условие всегда выполнялось, нужно взять наименьшие значения для и , чтобы при больших значениях переменных точно было меньше либо равно левой части.

При и , , .

Значит, .

Идея решения:

Перебираем целые неотрицательные значения по убыванию (в коде — от 500 до 1). Для каждого вложенными циклами for перебираем все неотрицательные целые числа и (в коде — от 0 до 299) и проверяем выражение

Если найдётся хотя бы одна пара , для которой выражение ложно, текущее отбрасываем. Первое , для которого выражение истинно для всех перебранных , и будет искомым наибольшим.

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

# перебираем возможные значения A по убыванию
for A in range(500, 1, -1):
    # предполагаем, что A подходит
    flag = True
    # перебираем неотрицательные x
    for x in range(300):
        # перебираем неотрицательные y
        for y in range(300):
            # проверяем выражение
            p = (5 * x + 7 * y >= A) or (x <= 40) or (y < 7)
            # если выражение ложно для текущей пары, A не подходит
            if p == 0:
                flag = False
                break
        # если A уже не подходит, прерываем цикл по x
        if flag == 0:
            break
    # если A подходит для всех x,y — выводим и прекращаем поиск
    if flag:
        print(A)
        break

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

Чтобы дизъюнкция была истинной при любом неотрицательном целом значении и рассмотрим случай, когда и

Это эквивалентно следующей системе:

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

Значит, значение при заданных условиях — 19.

Идея решения:

Перебираем целые неотрицательные значения по возрастанию (в коде — от 0 до 999). Для каждого вложенными циклами for перебираем все неотрицательные целые числа и (в коде — от 0 до 99) и проверяем выражение

Если найдётся хотя бы одна пара , для которой выражение ложно, текущее отбрасываем. Если же для всех перебранных выражение истинно, текущее считается подходящим. Поскольку требуется найти наибольшее такое , в коде продолжаем перебор и фиксируем максимум всех подходящих .

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

# перебираем неотрицательные значения A
for a in range(0, 1000):
    # переменная-флаг, показывает, подходит ли текущее A
    c = 0
    # перебираем неотрицательные x
    for x in range(100):
        # перебираем неотрицательные y
        for y in range(100):
            # проверяем выражение для текущей пары x, y
            if ((3*x + 5*y != 150) or (a < x) or (x <= y)) == False:
                # если выражение ложно — A не подходит
                c = 1
                break
        # если A уже не подходит, прерываем цикл по x
        if c == 1:
            break
    # если A подходит для всех x,y — выводим
    if c == 0:
        print(a)

Решение 1 (руками)

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

Это эквивалентно следующей системе:

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

Значит, наименьшее значение при заданных условиях —

Идея решения:

Перебираем неотрицательные значения по возрастанию (в коде — от 0 до 999). Для каждого вложенными циклами for перебираем все неотрицательные целые числа и (в коде — от 0 до 999) и проверяем выражение

Если найдётся хотя бы одна пара , для которой выражение ложно, текущее отбрасываем. Если же для всех перебранных выражение истинно, текущее считается подходящим. Поскольку требуется найти наименьшее такое , перебор останавливаем на первом подходящем.

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

# функция проверяет, что для данного a выражение истинно для всех x,y
def f(a):
    # перебираем неотрицательные x
    for x in range(1000):
        # перебираем неотрицательные y
        for y in range(1000):
            # если выражение ложно для пары x,y — a не подходит
            if ((3 * x + 5 * y != 80) or (a > x) or (a > y)) == 0:
                return False
    # ни одной "плохой" пары не найдено — a подходит
    return True

# перебираем значения A по возрастанию
for a in range(1000):
    # если для текущего A выражение истинно для всех x,y
    if f(a):
        # выводим наименьшее подходящее A
        print(a)
        break

Сделаем отрицание известной части:

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

Для максимизации значения в левой части выражения с берем наибольшие то есть и наименьший .

Получаем . Откуда наименьшее .

Идея решения:

Перебираем неотрицательные значения по возрастанию (в коде — от 0 до 999). Для каждого вложенными циклами for перебираем все неотрицательные целые числа (в коде — от 0 до 99) и проверяем выражение

Если найдётся хотя бы одна тройка , для которой выражение ложно, текущее отбрасываем. Если же для всех перебранных выражение истинно, текущее считается подходящим. Поскольку требуется найти наименьшее такое , перебор останавливаем на первом подходящем.

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

# функция проверяет, что для данного a выражение истинно для всех x,y,z
def f(a):
    # перебираем неотрицательные x
    for x in range(100):
        # перебираем неотрицательные y
        for y in range(100):
            # перебираем неотрицательные z
            for z in range(100):
                # если выражение ложно для текущих x,y,z — a не подходит
                if ((10*x + 3*y - 5*z < a) or (z > y) or (y > 30) or (x > 50)) == False:
                    return False
    # ни одной "плохой" тройки не найдено — a подходит
    return True

# перебираем значения A по возрастанию
for a in range(1000):
    # если для текущего A выражение истинно для всех x,y,z
    if f(a):
        # выводим наименьшее подходящее A
        print(a)
        break

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

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

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

Если мы зафиксируем какое-то значение , то для выбранного минимальное значение (так как ). Значит, . Тогда минимальный подходящий , а соответствующий ему минимальный .

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

Идея решения:

Перебираем целые значения по убыванию (в коде — от 100 до 2). Для каждого вложенными циклами for перебираем натуральные числа и (в коде — от 1 до 999) и проверяем истинность выражения

Если найдётся хотя бы одна пара , для которой выражение ложно, текущее отбрасываем. Первое , для которого выражение истинно при всех перебранных , и будет искомым наибольшим.

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

# функция проверяет, что для данного a выражение истинно для всех x,y
def f(a):
    # перебираем натуральные x
    for x in range(1, 1000):
        # перебираем натуральные y
        for y in range(1, 1000):
            # если выражение ложно для текущих x,y — a не подходит
            if not (x + y <= 25 or y <= x + 3 or y >= a):
                return False
    # ни одной "плохой" пары не найдено — a подходит
    return True

# перебираем возможные значения A по убыванию
for a in range(100, 1, -1):
    # если для текущего A выражение истинно для всех x,y
    if f(a):
        # выводим наибольшее подходящее A
        print(a)
        break

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

Составим систему для тех случаев, когда выражение тождественно ложно:

Попробуем взять наименьшие x и y, то есть x = 21, y = 52.

Так как нам требуется, чтобы , то есть . Тогда .

Наибольшее значение A = 251.

 

Идея решения:

Перебираем целые неотрицательные значения по возрастанию (в коде — от 1 до 299). Для каждого вложенными циклами for перебираем положительные целые и (в коде — от 1 до 199) и проверяем истинность выражения

Если найдётся хотя бы одна пара , для которой выражение ложно, текущее отбрасываем. Последнее , для которого выражение истинно при всех перебранных , будет искомым наибольшим.

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

# функция проверяет, что для данного A выражение истинно для всех x,y
def f(x, y, A):
    # возвращаем логическое значение выражения
    return (7*x + 2*y >= A) or (x <= 20) or (y < 52)

ans = 0
# перебираем возможные значения A по возрастанию
for A in range(1, 300):
    flag = True
    # перебираем положительные x
    for x in range(1, 200):
        # перебираем положительные y
        for y in range(1, 200):
            # если выражение ложно для текущих x,y — A не подходит
            if not f(x, y, A):
                flag = False
                break
        if not flag:
            break
    # если для всех x,y выражение истинно — сохраняем A
    if flag:
        ans = A
# выводим наибольшее подходящее A
print(ans)

Сделаем отрицание известной части:

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

Тогда выбираем наименьшие и , то есть .

Наибольшее значение A = 17.

 

Идея решения:

Перебираем целые неотрицательные значения по убыванию (в коде — от 100 до 2). Для каждого вложенными циклами for перебираем целые неотрицательные и (в коде — от 0 до 299) и проверяем выполнение выражения

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

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

# функция проверяет, что для данного a выражение истинно для всех x,y
def f(x, y, a):
    return (x + 13 / 9 * y >= a) or (not (x >= y)) or (y < 7)

# перебираем возможные значения A по убыванию
for a in range(100, 1, -1):
    # если для всех x,y выражение истинно
    if all(f(x, y, a) for x in range(300) for y in range(300)):
        # выводим наибольшее подходящее A
        print(a)
        break

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

Найдем при каких и выражение ложно. Для этого отрицаем известную часть:

Нужно, чтобы для таких и выражение стало истинно. Значит нужно, чтобы неравенство для них выполнялось.

Наибольшее , . Тогда . Наименьшее .

Идея решения:

Перебираем целые значения по возрастанию (в коде — от -10 до 999). Для каждого вложенными циклами for перебираем натуральные и (в коде — от 1 до 2999) и проверяем выполнение выражения

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

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

# перебираем целые значения A
for a in range(-10, 1000):
    c = 0  # флаг, показывает, найдено ли ложное выражение
    # перебираем натуральные x
    for x in range(1, 3000):
        # перебираем натуральные y
        for y in range(1, 3000):
            # проверяем выражение
            if ((x > 16) or (y > 25) or (a > x + y)) == False:
                c = 1  # выражение ложно, A не подходит
                break
        if c == 1:  # если флаг поднят, выходим из цикла по x
            break
    if c == 0:  # если ложного выражения не найдено
        print(a)  # наименьшее подходящее A
        break  # останавливаем перебор

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

Найдем при каких и выражение ложно. Для этого отрицаем известную часть:

Нужно, чтобы для таких и выражение стало истинно. Значит нужно, чтобы неравенство для них выполнялось.

Наименьшее , . Тогда . Максимальное возможное .

Идея решения:

Перебираем целые значения по возрастанию (в коде — от -10 до 999). Для каждого вложенными циклами for перебираем натуральные и (в коде — от 1 до 2999) и проверяем выполнение выражения

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

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

# перебираем целые значения A
for a in range(-10, 1000):
    c = 0  # флаг, показывает, найдено ли ложное выражение
    # перебираем натуральные x
    for x in range(1, 3000):
        # перебираем натуральные y
        for y in range(1, 3000):
            # проверяем выражение
            if ((a < x + y) or (x >= 48) or (y > 2)) == False:
                c = 1  # выражение ложно, A не подходит
                break
        if c == 1:  # если флаг поднят, выходим из цикла по x
            break
    if c == 0:  # если ложного выражения не найдено
        print(a)  # наибольшее подходящее A