Дана программа:

 s = int(input())

 t = int(input())

 A = int(input())

 if s < A and t < 10:

  print("ДА")

 else:

  print("НЕТ")

Было проведено 9 запусков этой программы при которых в качестве значений

переменных s и t вводились следующие пары чисел:(16,12) (-8,-10) (18,2) (5,-5) (1,-9) (10,9) (-10,-2) (14,1) (20,5)

Укажите максимальное целое значение параметра А, при котором для указанных входных

данных программа напечатает «НЕТ» 5 раз.

Программа проверяет два условия: s < A и t < 10. Если оба выполняются, выводится «ДА», иначе – «НЕТ».

У нас есть 9 запусков с парами (s, t):

1. (16, 12): t = 12 не меньше 10 → всегда «НЕТ».
2. (–8, –10): t = –10 < 10; условие даётся s < A, то есть –8 < A. Если A ≤ –8, выводится «НЕТ», если A > –8 – «ДА».
3. (18, 2): 2 < 10; условие: 18 < A. При A ≤ 18 – «НЕТ», при A > 18 – «ДА».
4. (5, –5): –5 < 10; условие: 5 < A. При A ≤ 5 – «НЕТ», при A > 5 – «ДА».
5. (1, –9): –9 < 10; условие: 1 < A. При A ≤ 1 – «НЕТ», при A > 1 – «ДА».
6. (10, 9): 9 < 10; условие: 10 < A. При A ≤ 10 – «НЕТ», при A > 10 – «ДА».
7. (–10, –2): –2 < 10; условие: –10 < A. При A ≤ –10 – «НЕТ», при A > –10 – «ДА».
8. (14, 1): 1 < 10; условие: 14 < A. При A ≤ 14 – «НЕТ», при A > 14 – «ДА».
9. (20, 5): 5 < 10; условие: 20 < A. При A ≤ 20 – «НЕТ», при A > 20 – «ДА».

При поиске максимального целого A, для которого программа печатает «НЕТ» ровно 5 раз, рассмотрим, какие пары при достаточно больших A дают «ДА»:

– Если A слишком велико (например, A ≥ 21), то почти все условия (кроме первого, который всегда «НЕТ») выполняются, и число «НЕТ» уменьшится.
– С другой стороны, слишком маленькое A может давать ещё больше «НЕТ».

Заметим, что при A > 1, A > 5 и A > –8, A > –10 результаты для запусков 2, 4, 5, 7 будут гарантированно «ДА». Тогда остаются следующие пары, у которых результат зависит от A:
• Запуск 3: «ДА», если A > 18, иначе «НЕТ».
• Запуск 6: «ДА», если A > 10, иначе «НЕТ».
• Запуск 8: «ДА», если A > 14, иначе «НЕТ».
• Запуск 9: «ДА», если A > 20, иначе «НЕТ».
И, плюс запуск 1, который всегда «НЕТ».

Таким образом, если A превышает соответствующие пороги:
– Если A ≥ 21:
1 – «НЕТ»
3 – «ДА» (так как A > 18)
6 – «ДА» (A > 10)
8 – «ДА» (A > 14)
9 – «ДА» (A > 20)
Всего «НЕТ»: только запуск 1 → 1 раз.
– Если A находится между 11 и 10 включительно? Проверим интервал A от 6 до 10 (при условии, что A > 5, но A ≤ 10).

Возьмём, например, A = 10:
1. (16,12): всегда «НЕТ».
2. (–8,–10): 10 > –8 → «ДА».
3. (18,2): 10 ≤ 18 → «НЕТ».
4. (5,–5): 10 > 5 → «ДА».
5. (1,–9): 10 > 1 → «ДА».
6. (10,9): 10 ≤ 10 → «НЕТ» (так как 10 < 10 не выполняется).
7. (–10,–2): 10 > –10 → «ДА».
8. (14,1): 10 ≤ 14 → «НЕТ».
9. (20,5): 10 ≤ 20 → «НЕТ».

Таким образом, при A = 10 получаем «НЕТ» в запусках: 1, 3, 6, 8, 9 – итого 5 запусков.

Чтобы найти максимально возможное целое A, при котором количество «НЕТ» ровно 5, рассмотрим увеличение A:
• При A = 11:
1. Всегда «НЕТ».
2. «ДА».
3. 11 ≤ 18 → «НЕТ».
4. «ДА».
5. «ДА».
6. 11 > 10 → «ДА».
7. «ДА».
8. 11 ≤ 14 → «НЕТ».
9. 11 ≤ 20 → «НЕТ».
Получается: «НЕТ»: 1, 3, 8, 9 → 4 раза.

При дальнейшем увеличении A ещё меньше «НЕТ» (так как для A > 10, запуск 6 даст «ДА», и при A ≥ 15, запуск 8 даст «ДА», а при A ≥ 19, запуск 3 даст «ДА» и при A ≥ 21, запуск 9 даст «ДА»).

Таким образом, чтобы ровно 5 запусков давали «НЕТ», A должно оставаться не больше 10. В интервале от 6 до 10 (при A > 5, чтобы запуск 4 давал «ДА») число «НЕТ» остаётся постоянным:
• Для любого A из интервала [6, 10] результаты будут:
1. «НЕТ»
2. «ДА»
3. «НЕТ» (так как A ≤ 18)
4. «ДА»
5. «ДА»
6. «НЕТ» (так как A ≤ 10)
7. «ДА»
8. «НЕТ» (так как A ≤ 14)
9. «НЕТ» (так как A ≤ 20)
Итого получаем 5 «НЕТ»: запуск 1, 3, 6, 8, 9.

Так как требуется максимальное целое значение A, удовлетворяющее условию, ответ будет A = 10.

Ответ: 10.