Ввод-вывод данных, арифметические операции

print() умеет принимать несколько значений через запятую и сам ставит между ними пробел.

Значит, вся программа — это одна команда с шестью числами в скобках.

1. Пробел между значениями print() ставит сам — вручную его добавлять не нужно.
2. Числа пишутся без кавычек: это числа, а не текст.

# print() сам ставит по одному пробелу между значениями
print(4, 8, 15, 16, 23, 42)

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

Каждая новая команда print() печатает с новой строки.

Значит, команд нужно столько же, сколько чисел.

1. print() после печати всегда переводит строку — поэтому шесть команд дают шесть строк.

# каждая команда print() печатает с новой строки
print(4)
print(8)
print(15)
print(16)
print(23)
print(42)

Через несколько задач вы узнаете параметр sep — с ним эта же программа записывается одной строкой: print(4, 8, 15, 16, 23, 42, sep='\n'). Пока такого приёма мы не проходили, и шесть команд — правильное решение.

Прочитанное имя надо сохранить в переменную, иначе его негде взять.

Запятая — часть текста, а пробел после неё print() поставит сам.

1. print('Привет,', name) печатает «Привет,», затем пробел (его ставит сама команда) и имя.
2. Писать print('Привет, ', name) не нужно: получится два пробела подряд.

name = input()          # читаем имя и запоминаем его
print('Привет,', name)  # запятая — в тексте, пробел поставит сам print

Классическая ошибка — пробел и в кавычках, и от print(). Глазами такое не видно, а проверяющая программа разницу заметит.

Пока строку не сохранили в переменную, она потеряна: второй раз её не прочитать.

Нужны три переменные — по одной на каждую строку.

1. Три команды input() заполняют три переменные.
2. Печатаем в обратном порядке: сначала третью, потом вторую, потом первую.

s1 = input()   # первая строка
s2 = input()   # вторая
s3 = input()   # третья

print(s3)      # печатаем с конца
print(s2)
print(s1)

Порядок чтения менять нельзя — строки приходят одна за другой. Переворачивается только порядок печати.

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

Значит, дело не в тексте, а в разделителе sep.

1. Три слова — три значения в print().
2. sep='***' заменяет пробел между ними на три звёздочки.

# три слова, а между ними — свой разделитель
print('I', 'like', 'Python', sep='***')

Написать print('I*like*Python') тоже можно, но задача — научиться менять разделитель, а не набрать нужные символы руками.

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

В sep= можно поставить не только текст в кавычках, но и имя переменной.

1. Первым читаем разделитель, потом три строки — порядок задан условием.
2. sep=separator подставит в разделитель то, что лежит в переменной.

separator = input()   # чем разделять
s1 = input()
s2 = input()
s3 = input()

print(s1, s2, s3, sep=separator)   # разделитель берём из переменной

sep — обычный параметр, и ему всё равно, стоит там литерал '*' или переменная с тем же значением.

«Следующее число» — это то же число плюс один.

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

1. int(input()) даёт число, с которым можно считать.
2. Второе и третье получаются как number + 1 и number + 2 — переменную при этом менять не нужно.

number = int(input())   # int() обязателен: считать будем, а не печатать

print(number)
print(number + 1)
print(number + 2)

Отрицательные числа ничем не отличаются: -341 + 1 — это -340. Пример со вторым тестом в условии стоит именно для этого.

Возведение в степень в Python — это **, а не ^.

Надпись и число печатаются одной командой: print('Объем =', V).

1. Читаем ребро и сразу переводим в целое.
2. a ** 3 — куб, 6 * a ** 2 — шесть квадратов граней. Скобки не нужны: степень выполняется раньше умножения.

a = int(input())     # длина ребра

V = a ** 3          # объём: ребро в кубе
S = 6 * a ** 2      # площадь: шесть граней по a²

print('Объем =', V)
print('Площадь полной поверхности =', S)

Знак ^ в Python — это не степень, а другая операция (исключающее «или»). 2 ^ 3 даст 1, а не 8, и программа не сломается — просто соврёт.

Знак действия внутри строки — это текст в кавычках, а само действие — вне кавычек.

В одной команде print() спокойно уживаются числа, текст и вычисления.

1. print(a, '+', b, '=', a + b) печатает пять значений: число, знак, число, знак равенства и результат.
2. Пробелы между ними print() расставит сам.

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

# в кавычках — знак действия как текст, вне кавычек — само действие
print(a, '+', b, '=', a + b)
print(a, '-', b, '=', a - b)
print(a, '*', b, '=', a * b)

Если забыть int(), программа не упадёт: '2' + '7' даст 27, а умножение уже приведёт к ошибке. Тем и коварна забытая строка.

«Полное число метров» — это сколько раз в длине помещается 100 см; остаток отбрасывается.

Ровно это и делает целочисленное деление.

1. 345 // 100 — это 3, а 345 / 100 дало бы 3.45.
2. Дробная часть здесь не нужна вовсе, поэтому берём //.

centimeters = int(input())

# // отбрасывает остаток: 345 см — это 3 полных метра
print(centimeters // 100)

Обычное деление / в Python всегда даёт дробное число, даже когда делится нацело: 300 / 100 → 3.0. Для «полного числа» это уже неверный ответ.

Задача — про те самые две операции: сколько раз поместилось и что осталось.

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

1. k // n — сколько целых мандаринов достанется каждому.
2. k % n — то, что не поделилось и осталось в корзине.

n = int(input())   # школьников
k = int(input())   # мандаринов

print(k // n)      # каждому досталось
print(k % n)       # осталось в корзине

Проверить себя легко: k // n * n + k % n всегда равно k — розданное плюс остаток даёт всё, что было.

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

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

1. Если к числу прибавить единицу и разделить нацело на 2, чётное не изменится, а нечётное округлится вверх.
2. 99 → (99 + 1) // 2 = 50; 100 → (100 + 1) // 2 = 50.

n = int(input())

# +1 перед делением нацело даёт округление вверх:
# у чётного числа ничего не меняется, у нечётного добавляется единица
print((n + 1) // 2)

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

Часы — это сколько раз шестьдесят помещается в минутах; минуты — то, что осталось.

Точка в конце — часть текста; приклеить её к числу без лишнего пробела поможет отдельное значение в print()... или подумайте, как обойтись.

1. minutes // 60 — целые часы, minutes % 60 — оставшиеся минуты.
2. Слова «мин», «- это», «час», «минут.» печатаются как текст между числами; пробелы print() ставит сам.

minutes = int(input())

# // — целые часы, % — минуты, которые не сложились в час
print(minutes, 'мин - это', minutes // 60, 'час', minutes % 60, 'минут.')

Точка стоит внутри последнего куска текста — 'минут.'. Отдельным значением её ставить нельзя: print() поставил бы перед ней пробел.

Места 1–4 — первое купе, 5–8 — второе. Похоже на деление на 4, но что-то мешает.

Мешает место 4: оно ещё в первом купе, а 4 // 4 уже даёт 1. Сдвиньте нумерацию так, чтобы места считались от нуля.

1. Вычитаем единицу — места становятся 0…35, и каждая четвёрка идёт ровно от одного значения // 4.
2. Делим нацело на 4 и прибавляем единицу, чтобы вернуть счёт купе к привычному «с первого».

place = int(input())

# сдвигаем нумерацию к нулю, делим по четыре места и возвращаем счёт с единицы
print((place - 1) // 4 + 1)

Приём «−1, поделить, +1» встречается всюду, где что-то нумеруют с единицы: страницы в книге, коробки по n штук, ряды в зале.