Встроенные функции, строки, модуль math, цикл for

Развилки тут не нужны вовсе: обе функции принимают сколько угодно аргументов.

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

1. Читаем пять чисел в пять переменных.
2. min(a, b, c, d, e) и max(a, b, c, d, e) дают ответы сразу.

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

print('Наименьшее число =', min(a, b, c, d, e))
print('Наибольшее число =', max(a, b, c, d, e))

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

Крайние значения находятся сразу: max() и min().

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

1. Наибольшее — max(a, b, c), наименьшее — min(a, b, c).
2. Среднее — это сумма всех трёх минус наибольшее и наименьшее.
3. Печатаем в порядке: наибольшее, среднее, наименьшее.

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

print(max(a, b, c))
# среднее = сумма всех трёх минус крайние
print(a + b + c - min(a, b, c) - max(a, b, c))
print(min(a, b, c))

Приём с суммой работает и когда числа совпадают: у 5, 5, 3 наибольшее 5, наименьшее 3, а среднее 13 − 3 − 5 = 5. Разбор случаев через if дал бы то же самое, но строк в пять раз больше.

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

float(input()) можно поставить прямо внутрь abs() — отдельная переменная не обязательна.

1. Каждое слагаемое — это abs(float(input())).
2. Пять таких слагаемых складываются в одном print().

print(abs(float(input())) + abs(float(input())) + abs(float(input()))
      + abs(float(input())) + abs(float(input())))

Программа честно уложилась в одну команду — и стала неудобочитаемой. Строка, в которой сложно даже сосчитать скобки, ошибку прячет, а не предотвращает. Вариант с пятью переменными длиннее, но понятнее — и он лучше. Коротко ≠ хорошо.

Вертикальные палочки в формуле — это модуль, то есть abs().

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

1. Разность координат по горизонтали берём по модулю: abs(p1 - q1).
2. То же по вертикали: abs(p2 - q2).
3. Складываем.

p1 = int(input())
p2 = int(input())
q1 = int(input())
q2 = int(input())

# модуль нужен, чтобы порядок точек не влиял на ответ
print(abs(p1 - q1) + abs(p2 - q2))

Без abs() расстояние вышло бы отрицательным, стоит поменять точки местами. Модуль здесь — не украшение формулы, а то, что делает её симметричной.

Пробелы между словами print() расставит сам — а вот восклицательный знак должен встать вплотную к фамилии.

Вплотную — значит, склеить: surname + '!'.

1. Читаем имя и фамилию.
2. Печатаем четыре значения: слово Hello, имя, фамилию со знаком и остаток фразы.
3. Знак приклеиваем конкатенацией, иначе print() вставит перед ним пробел.

name = input()
surname = input()

# '!' приклеиваем к фамилии, иначе print поставит перед ним пробел
print('Hello', name, surname + '!', 'You just delved into Python')

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

Сравнивать надо не сами названия, а их длины — len().

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

1. Если длина первого меньше длин обоих остальных — самое короткое найдено.
2. Иначе выбор между вторым и третьим — одно сравнение.
3. Для самого длинного — то же самое, но со знаком «больше».

a = input()
b = input()
c = input()

# самое короткое
if len(a) < len(b) and len(a) < len(c):
    print(a)
elif len(b) < len(c):
    print(b)
else:
    print(c)

# самое длинное — те же сравнения наоборот
if len(a) > len(b) and len(a) > len(c):
    print(a)
elif len(b) > len(c):
    print(b)
else:
    print(c)

min() и max() здесь не помогут: они сравнивали бы сами строки по алфавиту, а не по длине. Сравнивать надо длины, а печатать — строки, и развилка тут неизбежна.

Вся задача — одна проверка оператором in.

Искомое слово пишется в кавычках, а строка, в которой ищем, лежит в переменной.

1. Читаем строку.
2. if 'синий' in text: — печатаем YES, иначе NO.

text = input()

if 'синий' in text:
    print('YES')
else:
    print('NO')

Порядок в записи важен: 'синий' in text — это «ищем синий внутри текста». Написав наоборот, вы будете искать целый текст внутри слова «синий» и почти всегда получите NO.

Проверок две, и обе обязательны.

«Обе обязательны» — это and.

1. Первая проверка: '@' in address.
2. Вторая: '.' in address.
3. Соединяем через and — годится только адрес, где есть и то и другое.

address = input()

# нужны оба символа сразу, поэтому and
if '@' in address and '.' in address:
    print('YES')
else:
    print('NO')

Такая проверка пропустит и @., и а@б., но задача ровно такая: отсечь заведомо неверное. Настоящая проверка адреса — это уже разбор строки по частям, и он будет на шестом занятии.

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

Корень живёт в модуле math, значит, его надо подключить в первой строке.

1. Читаем четыре числа как float — координаты могут быть дробными.
2. Считаем (x1 - x2) 2 + (y1 - y2) 2.
3. Берём от суммы корень: math.sqrt(...).

import math

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

# теорема Пифагора: корень из суммы квадратов катетов
print(math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2))

Модуль здесь не нужен: квадрат и так делает разность неотрицательной. Сравните с манхэттенским расстоянием из задачи 3.4 — там abs() был обязателен, а здесь его роль играет возведение в квадрат.

Площадь круга — πR², длина окружности — 2πR.

π берётся из модуля math и пишется как math.pi.

1. Подключаем math, читаем радиус как float.
2. Площадь: math.pi * R ** 2.
3. Длина: 2 * math.pi * R.

import math

R = float(input())

print(math.pi * R ** 2)    # площадь круга
print(2 * math.pi * R)     # длина окружности

math.pi — это π с полной точностью типа float, а 3.14 даёт ошибку уже в третьем знаке. Там, где готовая константа есть, писать её вручную незачем.

Всё решает дискриминант D = b² − 4ac: больше нуля — два корня, равен нулю — один, меньше — ни одного.

Формула корня — (−b ± √D) / 2a. Который из двух окажется меньше, зависит от знака a, поэтому порядок вывода лучше не угадывать.

1. Считаем дискриминант.
2. Каскад из трёх веток: D > 0, D == 0, иначе.
3. При двух корнях печатаем min и max от них — так порядок возрастания получится при любом знаке a.

import math

a = float(input())
b = float(input())
c = float(input())

D = b ** 2 - 4 * a * c

if D > 0:
    x1 = (-b + math.sqrt(D)) / (2 * a)
    x2 = (-b - math.sqrt(D)) / (2 * a)
    print(min(x1, x2))   # min и max — чтобы порядок не зависел от знака a
    print(max(x1, x2))
elif D == 0:
    print(-b / (2 * a))
else:
    print('Нет корней')

Печатать x1, потом x2 заманчиво, но при отрицательном a больший корень получается первым, и порядок ломается. min и max избавляют от разбора знаков.

Формула переносится в код почти буквально; тангенс и π живут в math.

Аргумент тангенса — уже в радианах: π/n переводить не нужно.

1. Читаем n как целое, a — как вещественное.
2. Считаем знаменатель 4 * math.tan(math.pi / n).
3. Делим на него n * a ** 2.

import math

n = int(input())
a = float(input())

# π/n уже в радианах — переводить ничего не нужно
print(n * a ** 2 / (4 * math.tan(math.pi / n)))

Квадрат со стороной 10 даёт 100.00000000000001 вместо ровной сотни — тот самый хвост типа float, о котором говорилось на прошлом занятии. Формула верна, просто тангенс 45° вычисляется приближённо.

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

Переводить трижды не нужно: заведите переменную с углом в радианах.

1. math.radians(x) даёт угол в радианах.
2. Считаем math.sin(...), math.cos(...) и math.tan(...) от него.
3. Тангенс возводим в квадрат — ** 2 — и складываем все три слагаемых.

import math

x = float(input())
angle = math.radians(x)   # переводим градусы в радианы один раз

print(math.sin(angle) + math.cos(angle) + math.tan(angle) ** 2)

Если забыть перевод, программа не сломается — она посчитает синус угла в радианах и выдаст правдоподобное, но неверное число. Такие ошибки самые неприятные: результат есть, и он неправильный. Проверяйте себя на нуле: sin 0 + cos 0 + tg² 0 = 0 + 1 + 0 = 1.

Обе функции есть в math и называются ровно так, как читаются их значки.

У целого числа пол и потолок совпадают — проверьте это вторым примером.

1. math.ceil(x) — вверх, math.floor(x) — вниз.
2. Складываем результаты.

import math

x = float(input())

print(math.ceil(x) + math.floor(x))

round() тут не подойдёт: он округляет к ближайшему, а нам нужны обе стороны сразу. У 3.8 это 4 и 3, а round() дал бы 4 дважды.

Сколько раз повторять — известно заранее, значит, нужен for.

Переменная цикла в теле не понадобится: печатается одно и то же.

1. Читаем строку, потом число (его — через int()).
2. for i in range(n) повторит тело ровно n раз.

sentence = input()
n = int(input())

for i in range(n):
    print(sentence)

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

Строка из 19 звёздочек получается умножением: '*' * 19.

Осталось напечатать её n раз — это цикл.

1. Читаем высоту.
2. В цикле range(n) печатаем '*' * 19.

n = int(input())

for i in range(n):
    print('*' * 19)   # ширина одна и та же на каждой строке

Ширина здесь постоянная, поэтому строка внутри цикла не меняется. В следующей задаче она станет зависеть от номера шага — и прямоугольник превратится в треугольник.

Число звёздочек в строках убывает: n, n−1, …, 1.

range() умеет считать в обратную сторону — третьим параметром задаётся шаг, и он может быть отрицательным.

1. Нужны длины от n до 1 включительно.
2. range(n, 0, -1) даёт ровно их: старт n, стоп 0 (не включается), шаг −1.
3. На каждом шаге печатаем '*' * i.

n = int(input())

# range с отрицательным шагом: n, n-1, …, 1
for i in range(n, 0, -1):
    print('*' * i)

Можно было бы идти и вперёд, печатая '*' * (n - i), — но тогда придётся в уме пересчитывать номер шага в длину строки. Обратный отсчёт делает это за нас.

Рост на p процентов — это умножение на (1 + p/100), а не прибавление p.

В первый день популяция ещё не выросла: печатать надо до умножения, а не после.

1. Заводим переменную с начальной численностью — вещественную, потому что после первого же роста она перестанет быть целой.
2. Цикл идёт по номерам дней: range(1, n + 1).
3. На каждом шаге сначала печатаем день и текущую численность, потом умножаем её на (1 + p/100).

m = int(input())   # стартовое количество
p = int(input())   # прирост в процентах за сутки
n = int(input())   # сколько дней считаем

population = float(m)   # дальше численность станет дробной

for day in range(1, n + 1):
    print(day, population)
    population = population * (1 + p / 100)

Порядок «сначала напечатать, потом умножить» и даёт первый день без прироста. Поменяйте строки местами — и первый день окажется уже вторым. А float(m) нужен ради вывода: в примере стоит 10.0, а не 10.