Условный оператор, логические операторы

Последняя цифра — это остаток от деления на 10. А как добраться до предпоследней?

Деление нацело на 10 отбрасывает последнюю цифру: 1852 // 10 — это 185. Значит, любую цифру можно сначала «выдвинуть» в конец, а потом взять остатком.

1. Первая цифра — n // 1000: тысячи целиком.
2. Вторая — сначала отбрасываем две последние цифры (n // 100), потом берём остаток: n // 100 % 10.
3. Третья — то же самое, но отбрасываем одну цифру: n // 10 % 10.
4. Четвёртая — просто остаток: n % 10.

n = int(input())

print(n // 1000)      # тысячи
print(n // 100 % 10)  # выдвинули сотни в конец и взяли остаток
print(n // 10 % 10)   # то же с десятками
print(n % 10)         # единицы — просто остаток

Приём «поделить нацело, потом взять остаток» вытаскивает любую цифру числа. Он ещё пригодится: на пятом занятии им же будем разбирать число по цифрам в цикле.

Строки сравниваются тем же ==, что и числа.

Переводить введённое в число здесь не нужно — пароль и есть текст.

1. Читаем две строки в две переменные.
2. Сравниваем их: совпали — печатаем одно, не совпали — другое.

first = input()
second = input()

if first == second:      # у строк == работает так же, как у чисел
    print('Пароль принят')
else:
    print('Пароль не принят')

Сравнение строк — посимвольное и с учётом регистра: 'Qwerty' и 'qwerty' не равны. Для пароля это ровно то, что нужно.

Развилка тут ровно одна: либо первое меньше, либо второе.

Печатать можно прямо в каждой ветке — заводить лишнюю переменную не обязательно.

1. Сравниваем первое со вторым.
2. Если первое меньше — печатаем его, иначе печатаем второе.

a = int(input())
b = int(input())

if a < b:
    print(a)
else:
    print(b)

На следующем занятии появится встроенная функция min(), и та же задача решится одной строкой. Но развилку надо уметь писать руками — min() не поможет там, где условие сложнее.

Групп четыре, а значит, проверок нужно три: последняя ветка достаётся всем оставшимся.

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

1. Первая проверка: age <= 13 — детство.
2. Вторая: age <= 24. Сюда попадут только те, кому больше 13, — значит, писать 14 <= age <= 24 не нужно.
3. Третья: age <= 59. Всё, что осталось, — старость.

age = int(input())

if age <= 13:
    print('детство')
elif age <= 24:      # сюда попадут только те, кому больше 13
    print('молодость')
elif age <= 59:
    print('зрелость')
else:
    print('старость')

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

Условий на самом деле два: число больше левой границы и меньше правой.

В Python их не нужно соединять через and — сравнения складываются в цепочку.

1. Границы в промежуток не входят, поэтому знаки строгие: <, а не <=.
2. Цепочка -1 < x < 17 читается ровно как запись из условия.

x = int(input())

if -1 < x < 17:      # круглые скобки в условии — знаки строгие
    print('Принадлежит')
else:
    print('Не принадлежит')

Всё решают знаки: у промежутка (−1; 17) они строгие, а у [−1; 17] были бы нестрогими. Проверяется это ровно на границах — 17 в примерах стоит именно для этого. Через связку то же условие пишется как x > -1 and x < 17: верно, но длиннее.

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

«Хотя бы в один» — это or, а не and. Условие с and не выполнится никогда: одно число не может быть одновременно меньше −3 и больше 7.

1. Первый промежуток: x <= -3. Второй: x >= 7.
2. Соединяем их через or — годится любой из двух.

x = int(input())

# годится любой из промежутков, поэтому or, а не and
if x <= -3 or x >= 7:
    print('Принадлежит')
else:
    print('Не принадлежит')

Проверить себя просто: подставьте ноль. С or получится «Не принадлежит» — верно; с and программа отвечала бы «Не принадлежит» вообще всегда, и на этом примере ошибку было бы не видно.

«Делится нацело на 7» — это остаток от деления на 7 равен нулю.

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

1. Четырёхзначное — значит, от 1000 до 9999: цепочка 1000 <= n <= 9999.
2. Делимость: n % 7 == 0 или n % 17 == 0.
3. Скобки обязательны: без них and сработает раньше or, и число 7 сойдёт за красивое.

n = int(input())

# скобки обязательны: без них and выполнится раньше or
if 1000 <= n <= 9999 and (n % 7 == 0 or n % 17 == 0):
    print('YES')
else:
    print('NO')

Без скобок условие читается как «(четырёхзначное и делится на 7) или (делится на 17)» — и однозначное 17 объявляется красивым. Ошибка тихая: на большинстве примеров ответ совпадает.

Король попадает туда, где номер столбца отличается не больше чем на единицу и номер строки — тоже.

«Отличается не больше чем на 1» — это разность от −1 до 1. А такое проверяется цепочкой.

1. Разность столбцов должна лежать в промежутке от −1 до 1: -1 <= x1 - x2 <= 1.
2. То же самое для строк.
3. Оба условия обязательны — соединяем через and.

x1 = int(input())
y1 = int(input())
x2 = int(input())
y2 = int(input())

# ход короля: и столбец, и строка меняются не больше чем на единицу
if -1 <= x1 - x2 <= 1 and -1 <= y1 - y2 <= 1:
    print('YES')
else:
    print('NO')

Разбирать восемь направлений по отдельности не нужно — все они укладываются в два условия на разности. На следующем занятии появится abs(), и запись станет ещё короче: abs(x1 - x2) <= 1.

Проверять надо в правильном порядке: равносторонний треугольник тоже равнобедренный, а наоборот — не всегда.

Равенство трёх сторон проверяется цепочкой a == b == c, а «хотя бы две равны» — тремя сравнениями через or.

1. Сначала самый строгий случай: все три стороны равны — равносторонний.
2. Потом «хотя бы две равны»: a == b or a == c or b == c. Сюда попадут только те, кто не прошёл первую проверку.
3. Всё остальное — разносторонний.

a, b, c = int(input()), int(input()), int(input())

if a == b == c:                      # сначала самый строгий случай
    print('Равносторонний')
elif a == b or a == c or b == c:     # хотя бы две стороны равны
    print('Равнобедренный')
else:
    print('Разносторонний')

Порядок проверок здесь важнее самих условий: поставьте «равнобедренный» первым — и равносторонний треугольник никогда не будет опознан, потому что две равные стороны у него тоже есть.

Операций четыре, плюс случай «ничего из перечисленного» — это ровно каскад из четырёх проверок и else.

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

1. Читаем два числа и строку с операцией.
2. Каскад: +, -, *, /, иначе — «Неверная операция».
3. Внутри ветки деления — своя развилка: если второе число ноль, печатаем предупреждение, иначе делим.

a = int(input())
b = int(input())
operation = input()

if operation == '+':
    print(a + b)
elif operation == '-':
    print(a - b)
elif operation == '*':
    print(a * b)
elif operation == '/':
    if b == 0:                       # вложенная развилка: только для деления
        print('На ноль делить нельзя!')
    else:
        print(a / b)
else:
    print('Неверная операция')

Проверку b == 0 нельзя вынести наверх: при умножении на ноль никакой ошибки нет, и программа зря ругалась бы. Вложенность здесь не украшение, а точное место проверки.

Нарисуйте два отрезка на прямой. Где начинается их общая часть — в левом из начал или в правом?

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

1. Находим начало пересечения: большее из a₁ и a₂.
2. Находим конец: меньшее из b₁ и b₂.
3. Если начало меньше конца — это отрезок; если равно — точка; если больше — отрезки не пересекаются.

a1 = int(input())
b1 = int(input())
a2 = int(input())
b2 = int(input())

# начало пересечения — правое из начал
if a1 > a2:
    left = a1
else:
    left = a2

# конец пересечения — левое из концов
if b1 < b2:
    right = b1
else:
    right = b2

if left < right:
    print(left, right)
elif left == right:
    print(left)
else:
    print('пустое множество')

Разбирать взаимное расположение отрезков случай за случаем (один внутри другого, налезают слева, справа…) — долго и легко что-нибудь забыть. Приём «правое из начал, левое из концов» покрывает все случаи сразу. На следующем занятии он сократится до двух строк с max() и min().

Выпишите координаты нескольких клеток одной диагонали: (1;1), (2;2), (3;3). Что у них общего?

У клеток восходящей диагонали одинакова разность x - y, у нисходящей — сумма x + y. Достаточно любого совпадения.

1. Восходящая диагональ: x1 - y1 == x2 - y2.
2. Нисходящая: x1 + y1 == x2 + y2.
3. Слон ходит по любой из двух — соединяем через or.

x1 = int(input())
y1 = int(input())
x2 = int(input())
y2 = int(input())

# на одной диагонали совпадает либо разность координат, либо сумма
if x1 - y1 == x2 - y2 or x1 + y1 == x2 + y2:
    print('YES')
else:
    print('NO')

Диагональ — это прямая y = x + b или y = -x + b. Проверка на равенство разностей и сумм — это и есть проверка «лежат ли обе клетки на одной такой прямой», только без единого умножения.

Дробная часть — это само число минус его целая часть.

Целую часть у положительного числа даёт int(), а хвост из лишних знаков убирает round().

1. Читаем число как float.
2. Вычитаем из него int(x) — то, что останется, и есть дробная часть.
3. Округляем результат до двух знаков: без этого вместо 0.45 напечаталось бы 0.45000000000000284.

x = float(input())

# int() отбрасывает дробную часть, вычитание оставляет только её,
# а round() убирает хвост, который тянется от двоичного хранения
print(round(x - int(x), 2))

Без round() программа напечатала бы 0.45000000000000284 — верное число с длинным хвостом. Округление до двух знаков — это то, чего просит пример в условии; если бы понадобились все знаки, round() пришлось бы убрать.

Умножьте число на 10 — нужная цифра станет последней в целой части.

Дальше — приёмы первого занятия: отбросить дробь и взять остаток от деления на 10.

1. x * 10 сдвигает точку на разряд вправо: 1.5 превращается в 15.0.
2. int() отбрасывает всё после точки — остаётся целое 15.
3. % 10 берёт последнюю цифру: 5.

x = float(input())

# сдвигаем точку на разряд, отбрасываем остаток дроби и берём последнюю цифру
print(int(x * 10) % 10)

Три знакомых действия подряд — вот и весь ответ. Здесь особенно видно, зачем нужен int(): у дробного числа остаток % тоже дробный, и без него ответом было бы 5.0, а то и 4.999999.