Материалы учителя — Python 7 класс

Автоматическая проверка тем 1–2: баллы задачи пропорциональны числу пройденных тестов. Оценки: «5» от 85%, «4» от 65%, «3» от 40%. Это отдельная автоматическая оценка; методические критерии ниже позволяют учителю оценить этапы алгоритма и понимание.

Решения, дополнительные тесты, критерии оценивания и вопросы ученикам. Тема 1 — 6 задач и 20 баллов; тема 2 — 10 задач и 40 баллов. Тема 3 — C1–C12 и самостоятельные варианты; тема 4 — D1–D16. Для циклов действует тренировочная проверка без автоматической отметки; для строк — тренировочная автопроверка D1–D16 с учётом значимых пробелов, понимание оценивает учитель.

Тема 1 — ввод-вывод и арифметика

Комплект рассчитан на начинающих семиклассников после соответствующей теории. Ориентир — 45 минут; это методическая оценка, ещё не проверенная на классе. Если класс только осваивает IDLE, разумно выделить два урока. Объявите выбранный объём работы заранее.

Оценивание

Полный комплект — 20 баллов. Предлагаемая шкала: 17–20 — «5», 13–16 — «4», 8–12 — «3», 0–7 — «2». Это рекомендация учителю, а не обязательный школьный норматив.

В каждой задаче 1 балл — корректный ввод, преобразование типов и формат вывода. Остальные баллы — за перечисленные ниже части алгоритма. Не начисляйте один балл дважды. При локальной синтаксической ошибке оценивайте видимые части алгоритма вручную; полный балл — только за работающее решение. Количество пройденных тестов помогает найти ошибку, но не заменяет эту рубрику. Правильное альтернативное решение оценивайте по тем же критериям. Использование другого способа форматирования не является ошибкой. Условия/циклы не требуются в наборе A; если ученик использует их, проверьте понимание, а не снимайте баллы автоматически.

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

A1. Бирка команды (2 балла)

Проверяем: str, int, input(), точный вывод.

Баллы сверх 1 балла за ввод/вывод: 1 балл за прибавление 1 к числу n.

team = input()
code = input()
n = int(input())
print(team, code, sep="-")
print(n + 1)

Частая ошибка: int() для кода убирает ведущие нули; n без int() остаётся строкой.

Вопрос ученику: Почему код 007 нужно читать как строку, а число уже испытанных роботов — как int?

Тесты 1–2 открыты ученику. Остальные предназначены учителю. В таблице / означает переход на новую строку.

№	Ввод	Ожидаемый вывод
1	`Vega / 007 / 9`	`Vega-007 / 10`
2	`Orion / 12 / 0`	`Orion-12 / 1`
3	`A / 0 / 1`	`A-0 / 2`
4	`Test / 000000 / 999`	`Test-000000 / 1000`
5	`Robot / 100 / 99`	`Robot-100 / 100`
6	`X / 0009 / 8`	`X-0009 / 9`

A2. Закупка для мастерской (3 балла)

Проверяем: int, умножение, сложение и вычитание.

Баллы сверх 1 балла за ввод/вывод: 1 балл за сумму стоимости обоих видов товаров; 1 за верную оставшуюся сумму.

n = int(input())
p = int(input())
m = int(input())
q = int(input())
b = int(input())
cost = n * p + m * q
print(cost)
print(b - cost)

Частая ошибка: Складывают количество и цену; считают только один вид товара; путают порядок вычитания.

Вопрос ученику: Что напечатает программа, если покупка стоит ровно столько, сколько выделено?

Тесты 1–2 открыты ученику. Остальные предназначены учителю. В таблице / означает переход на новую строку.

№	Ввод	Ожидаемый вывод
1	`3 / 120 / 4 / 35 / 600`	`500 / 100`
2	`2 / 100 / 0 / 25 / 200`	`200 / 0`
3	`0 / 1 / 0 / 1 / 0`	`0 / 0`
4	`0 / 20 / 3 / 7 / 30`	`21 / 9`
5	`100 / 1000 / 100 / 1000 / 1000000`	`200000 / 800000`
6	`1 / 7 / 2 / 9 / 100`	`25 / 75`

A3. Средняя скорость робота (3 балла)

Проверяем: float, int, обычное деление /.

Баллы сверх 1 балла за ввод/вывод: 1 балл за сумму обоих расстояний; 1 за обычное деление всей суммы на время.

d1 = float(input())
d2 = float(input())
t = int(input())
print((d1 + d2) / t)

Частая ошибка: Используют // или int(input()) для дробных длин; забывают скобки вокруг суммы.

Вопрос ученику: Почему здесь нужны / и скобки? Чем отличался бы результат (d1 + d2) // t?

Тесты 1–2 открыты ученику. Остальные предназначены учителю. В таблице / означает переход на новую строку.

№	Ввод	Ожидаемый вывод
1	`2.5 / 4.5 / 4`	`1.75`
2	`1 / 1 / 3`	`0.6666666666666666`
3	`0 / 0 / 1`	`0.0`
4	`0.5 / 0.25 / 2`	`0.375`
5	`1000 / 1000 / 1`	`2000.0`
6	`0.1 / 0.2 / 10`	`0.03`

A4. Полая модель (3 балла)

Проверяем: степень ** и разность объёмов.

Баллы сверх 1 балла за ввод/вывод: 1 балл за вычисление двух объёмов; 1 за их разность.

a = int(input())
b = int(input())
print(a ** 3 - b ** 3)

Частая ошибка: Используют ^ вместо ** или вычисляют (a - b) ** 3.

Вопрос ученику: Почему объём материала нельзя вычислить как (a - b) ** 3?

Тесты 1–2 открыты ученику. Остальные предназначены учителю. В таблице / означает переход на новую строку.

№	Ввод	Ожидаемый вывод
1	`5 / 3`	`98`
2	`4 / 0`	`64`
3	`1 / 0`	`1`
4	`100 / 99`	`29701`
5	`100 / 0`	`1000000`
6	`3 / 2`	`19`

A5. Наклейки для наборов (4 балла)

Проверяем: составное вычисление, // и %.

Баллы сверх 1 балла за ввод/вывод: 1 балл за общее число наклеек; 1 за количество полных наборов; 1 за остаток.

r = int(input())
k = int(input())
s = int(input())
total = r * k
print(total // s, total % s)

Частая ошибка: Делят каждый рулон отдельно, хотя остатки можно объединить; путают // и %.

Вопрос ученику: При r = 2, k = 5, s = 6 почему получится один набор, а не ноль?

Тесты 1–2 открыты ученику. Остальные предназначены учителю. В таблице / означает переход на новую строку.

№	Ввод	Ожидаемый вывод
1	`3 / 14 / 8`	`5 2`
2	`2 / 12 / 6`	`4 0`
3	`0 / 10 / 3`	`0 0`
4	`1 / 3 / 8`	`0 3`
5	`2 / 5 / 6`	`1 4`
6	`1000 / 1000 / 1`	`1000000 0`
7	`1000 / 999 / 1000`	`999 0`

A6. Метка кадра (5 баллов)

Проверяем: последовательное разложение, // и %.

Баллы сверх 1 балла за ввод/вывод: 1 балл за полные секунды; 1 за минуты; 1 за секунды внутри минуты; 1 за кадр внутри секунды.

n = int(input())
f = int(input())
seconds = n // f
print(seconds // 60, seconds % 60, n % f)

Частая ошибка: Считают кадры с 1; выводят все секунды вместо секунд внутри минуты; минуты ошибочно ограничивают 59.

Вопрос ученику: Как изменится ответ при переходе от кадра 1499 к 1500, если f = 25?

Тесты 1–2 открыты ученику. Остальные предназначены учителю. В таблице / означает переход на новую строку.

№	Ввод	Ожидаемый вывод
1	`1582 / 25`	`1 3 7`
2	`1499 / 25`	`0 59 24`
3	`1500 / 25`	`1 0 0`
4	`0 / 30`	`0 0 0`
5	`25 / 25`	`0 1 0`
6	`90000 / 25`	`60 0 0`
7	`10000000 / 120`	`1388 53 40`
8	`61 / 1`	`1 1 0`

Тема 2 — условия if/else

Решения B1–B10: от простых сравнений до вложенных условий. Базовый блок B1–B6 — 20 баллов; продолжение B7–B10 — ещё 20 баллов.

Открыть ученические задания по условиям

Оценивание

Все 10 задач — 40 баллов. Предлагаемая шкала: 34–40 — «5», 26–33 — «4», 16–25 — «3», 0–15 — «2». Для базового блока B1–B6 сохраняется шкала на 20 баллов: 17–20 — «5», 13–16 — «4», 8–12 — «3», 0–7 — «2». Это методическая рекомендация.

В каждой задаче 1 балл — корректный ввод, преобразование типов и формат вывода. Остальные баллы — за перечисленные ниже части алгоритма. Не начисляйте один балл дважды. При локальной синтаксической ошибке оценивайте видимые части алгоритма вручную; полный балл — только за работающее решение. Количество пройденных тестов помогает найти ошибку, но не заменяет эту рубрику. Правильное альтернативное решение оценивайте по тем же критериям. Использование другого способа форматирования не является ошибкой. В наборе B проверяется применение условий; циклы не требуются. Правильное альтернативное решение оценивайте по тем же критериям.

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

B1. Грузовая платформа (2 балла)

Проверяем: if/else, граница ≤.

Баллы сверх 1 балла за ввод/вывод: 1 балл за правильный выбор, включая случай равенства.

m = int(input())
c = int(input())
if m <= c:
    print("YES")
else:
    print("NO")

Частая ошибка: Проверяют m < c и ошибаются на предельной массе.

Вопрос ученику: Каким будет ответ, если m равно c? Какая часть сравнения за это отвечает?

Тесты 1–2 открыты ученику. Остальные предназначены учителю. В таблице / означает переход на новую строку.

№	Ввод	Ожидаемый вывод
1	`750 / 1000`	`YES`
2	`1001 / 1000`	`NO`
3	`1000 / 1000`	`YES`
4	`0 / 1`	`YES`
5	`100000 / 100000`	`YES`
6	`100000 / 1`	`NO`

B2. Ровные ряды на стенде (3 балла)

Проверяем: остаток и сравнение с нулём.

Баллы сверх 1 балла за ввод/вывод: 1 балл за остаток n % k; 1 за выбор ответа по равенству остатка нулю.

n = int(input())
k = int(input())
if n % k == 0:
    print("YES")
else:
    print("NO")

Частая ошибка: Сравнивают частное с нулём или путают n % k и k % n.

Вопрос ученику: Почему проверять нужно остаток, а не целую часть от деления?

Тесты 1–2 открыты ученику. Остальные предназначены учителю. В таблице / означает переход на новую строку.

№	Ввод	Ожидаемый вывод
1	`24 / 6`	`YES`
2	`25 / 6`	`NO`
3	`3 / 8`	`NO`
4	`7 / 7`	`YES`
5	`10000 / 1`	`YES`
6	`1 / 10000`	`NO`

B3. Температура хранения (3 балла)

Проверяем: and или цепочка сравнений, включённые границы.

Баллы сверх 1 балла за ввод/вывод: 1 балл за корректную нижнюю границу; 1 за верхнюю границу и одновременное выполнение ограничений.

t = int(input())
if -5 <= t <= 35:
    print("OK")
else:
    print("ALERT")

Частая ошибка: Пишут or вместо and; исключают одну из допустимых границ.

Вопрос ученику: Какой ошибочный результат может дать условие t >= -5 or t <= 35?

Тесты 1–2 открыты ученику. Остальные предназначены учителю. В таблице / означает переход на новую строку.

№	Ввод	Ожидаемый вывод
1	`20`	`OK`
2	`40`	`ALERT`
3	`-6`	`ALERT`
4	`-5`	`OK`
5	`35`	`OK`
6	`36`	`ALERT`
7	`-50`	`ALERT`
8	`80`	`ALERT`

B4. Допуск к испытаниям (4 балла)

Проверяем: сочетание and/or.

Баллы сверх 1 балла за ввод/вывод: 1 балл за возрастную границу; 1 за обязательность инструктажа в обычном допуске; 1 за независимый специальный допуск.

a = int(input())
t = int(input())
p = int(input())
if (a >= 14 and t == 1) or p == 1:
    print("YES")
else:
    print("NO")

Частая ошибка: Пишут a >= 14 and (t == 1 or p == 1), поэтому специальный допуск не работает для младших.

Вопрос ученику: Должен ли пройти ученик 13 лет без инструктажа, но со специальным допуском?

Тесты 1–2 открыты ученику. Остальные предназначены учителю. В таблице / означает переход на новую строку.

№	Ввод	Ожидаемый вывод
1	`14 / 1 / 0`	`YES`
2	`13 / 1 / 0`	`NO`
3	`14 / 0 / 0`	`NO`
4	`13 / 0 / 0`	`NO`
5	`13 / 0 / 1`	`YES`
6	`13 / 1 / 1`	`YES`
7	`14 / 0 / 1`	`YES`
8	`14 / 1 / 1`	`YES`
9	`7 / 0 / 1`	`YES`
10	`18 / 1 / 0`	`YES`

B5. Два заезда (4 балла)

Проверяем: три исхода, if/elif/else.

Баллы сверх 1 балла за ввод/вывод: 1 балл за победу первого; 1 за победу второго; 1 за ничью с единственной строкой ответа.

a = int(input())
b = int(input())
if a < b:
    print("FIRST")
elif a > b:
    print("SECOND")
else:
    print("DRAW")

Частая ошибка: Считают большим лучший результат; не выделяют ничью; независимые if дают лишние строки.

Вопрос ученику: Сколько строк должна вывести программа при одинаковом времени?

Тесты 1–2 открыты ученику. Остальные предназначены учителю. В таблице / означает переход на новую строку.

№	Ввод	Ожидаемый вывод
1	`42 / 47`	`FIRST`
2	`51 / 49`	`SECOND`
3	`45 / 45`	`DRAW`
4	`1 / 10000`	`FIRST`
5	`10000 / 1`	`SECOND`
6	`10000 / 10000`	`DRAW`

B6. Печать карточек (4 балла)

Проверяем: ветвление и кусочная стоимость.

Баллы сверх 1 балла за ввод/вывод: 1 балл за стоимость при 0 ≤ n ≤ 10; 1 за 300 рублей первых десяти при n > 10; 1 за добавку (n - 10) * 20.

n = int(input())
if n <= 10:
    cost = n * 30
else:
    cost = 10 * 30 + (n - 10) * 20
print(cost)

Частая ошибка: После 10 карточек применяют цену 20 рублей ко всему заказу.

Вопрос ученику: Почему заказ из 11 карточек стоит 320 рублей, а не 220?

Тесты 1–2 открыты ученику. Остальные предназначены учителю. В таблице / означает переход на новую строку.

№	Ввод	Ожидаемый вывод
1	`8`	`240`
2	`12`	`340`
3	`0`	`0`
4	`1`	`30`
5	`10`	`300`
6	`11`	`320`
7	`1000`	`20100`

B7. Самый быстрый из трёх (5 баллов)

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

Критерии: 1 балл за ввод/вывод; 1 за начальное значение; 1 за сравнение второго времени; 1 за сравнение третьего; 1 за случаи равенства и единый вывод.

a = int(input())
b = int(input())
c = int(input())
best = a
if b < best:
    best = b
if c < best:
    best = c
print(best)

Частая ошибка: Используют elif для второй проверки: после обновления по b время c уже не проверяется.

Вопрос ученику: Что получится для времён 30, 20, 10, если вторую проверку заменить на elif?

Первые два теста — примеры ученика. В таблице / означает перевод строки.

№	Ввод	Ожидаемый вывод
1	`42 / 39 / 45`	`39`
2	`30 / 30 / 35`	`30`
3	`1 / 1 / 1`	`1`
4	`1 / 1 / 2`	`1`
5	`1 / 1 / 10000`	`1`
6	`1 / 2 / 1`	`1`
7	`1 / 2 / 2`	`1`
8	`1 / 2 / 10000`	`1`
9	`1 / 10000 / 1`	`1`
10	`1 / 10000 / 2`	`1`
11	`1 / 10000 / 10000`	`1`
12	`2 / 1 / 1`	`1`
13	`2 / 1 / 2`	`1`
14	`2 / 1 / 10000`	`1`
15	`2 / 2 / 1`	`1`
16	`2 / 2 / 2`	`2`
17	`2 / 2 / 10000`	`2`
18	`2 / 10000 / 1`	`1`
19	`2 / 10000 / 2`	`2`
20	`2 / 10000 / 10000`	`2`
21	`10000 / 1 / 1`	`1`
22	`10000 / 1 / 2`	`1`
23	`10000 / 1 / 10000`	`1`
24	`10000 / 2 / 1`	`1`
25	`10000 / 2 / 2`	`2`
26	`10000 / 2 / 10000`	`2`
27	`10000 / 10000 / 1`	`1`
28	`10000 / 10000 / 2`	`2`
29	`10000 / 10000 / 10000`	`10000`

B8. Каркас треугольника (5 баллов)

Проверяем: Приоритет проверок, три неравенства и классификация.

Критерии: 1 балл за ввод/вывод; 1 за проверку существования во всех порядках сторон; 1 за равносторонний; 1 за равнобедренный; 1 за разносторонний и единственный ответ.

a = int(input())
b = int(input())
c = int(input())
if a + b <= c or a + c <= b or b + c <= a:
    print("NONE")
elif a == b and b == c:
    print("EQUILATERAL")
elif a == b or a == c or b == c:
    print("ISOSCELES")
else:
    print("SCALENE")

Частая ошибка: Не проверяют равенство суммы третьей стороне или считают равносторонний равнобедренным раньше отдельной проверки.

Вопрос ученику: Почему для 2, 2, 4 нельзя сразу напечатать ISOSCELES?

Первые два теста — примеры ученика. В таблице / означает перевод строки.

№	Ввод	Ожидаемый вывод
1	`3 / 4 / 5`	`SCALENE`
2	`2 / 2 / 4`	`NONE`
3	`5 / 5 / 5`	`EQUILATERAL`
4	`5 / 5 / 3`	`ISOSCELES`
5	`5 / 3 / 5`	`ISOSCELES`
6	`3 / 5 / 5`	`ISOSCELES`
7	`1 / 2 / 4`	`NONE`
8	`4 / 1 / 2`	`NONE`
9	`2 / 4 / 1`	`NONE`
10	`1000 / 1000 / 1`	`ISOSCELES`
11	`1 / 1 / 1`	`EQUILATERAL`
12	`1000 / 1 / 1`	`NONE`
13	`2 / 3 / 5`	`NONE`
14	`5 / 2 / 3`	`NONE`
15	`3 / 5 / 2`	`NONE`

B9. Где находится датчик (5 баллов)

Проверяем: Семь исходов, особые случаи до общей классификации.

Критерии: 1 балл за ввод/вывод; 1 за начало координат; 1 за обе оси; 1 за I и II четверти; 1 за III и IV четверти.

x = int(input())
y = int(input())
if x == 0 and y == 0:
    print("ORIGIN")
elif y == 0:
    print("X_AXIS")
elif x == 0:
    print("Y_AXIS")
elif x > 0 and y > 0:
    print("I")
elif x < 0 and y > 0:
    print("II")
elif x < 0 and y < 0:
    print("III")
else:
    print("IV")

Частая ошибка: Сначала проверяют ось и относят начало координат к X_AXIS; путают номер четверти.

Вопрос ученику: Почему проверка начала координат должна стоять раньше проверок осей?

Первые два теста — примеры ученика. В таблице / означает перевод строки.

№	Ввод	Ожидаемый вывод
1	`3 / -2`	`IV`
2	`0 / 5`	`Y_AXIS`
3	`-1000 / -1000`	`III`
4	`-1000 / 0`	`X_AXIS`
5	`-1000 / 1000`	`II`
6	`0 / -1000`	`Y_AXIS`
7	`0 / 0`	`ORIGIN`
8	`0 / 1000`	`Y_AXIS`
9	`1000 / -1000`	`IV`
10	`1000 / 0`	`X_AXIS`
11	`1000 / 1000`	`I`

B10. Тариф доставки (5 баллов)

Проверяем: Вложенные условия, граничные значения и независимая доплата.

Критерии: 1 балл за ввод/вывод; 1 за выбор зоны; 1 за интервалы зоны 0; 1 за интервалы зоны 1; 1 за срочную доплату во всех тарифах.

m = int(input())
z = int(input())
s = int(input())
if z == 0:
    if m <= 1000:
        cost = 100
    elif m <= 5000:
        cost = 180
    else:
        cost = 300
else:
    if m <= 1000:
        cost = 150
    elif m <= 5000:
        cost = 250
    else:
        cost = 400
if s == 1:
    cost = cost + 100
print(cost)

Частая ошибка: Срочную доплату добавляют только в одной ветке или относят 1000 и 5000 к следующему тарифу.

Вопрос ученику: Какая часть программы должна измениться при срочной доставке и почему её проверка стоит после выбора тарифа?

Первые два теста — примеры ученика. В таблице / означает перевод строки.

№	Ввод	Ожидаемый вывод
1	`750 / 0 / 0`	`100`
2	`5001 / 1 / 1`	`500`
3	`1 / 0 / 0`	`100`
4	`1 / 0 / 1`	`200`
5	`1 / 1 / 0`	`150`
6	`1 / 1 / 1`	`250`
7	`1000 / 0 / 0`	`100`
8	`1000 / 0 / 1`	`200`
9	`1000 / 1 / 0`	`150`
10	`1000 / 1 / 1`	`250`
11	`1001 / 0 / 0`	`180`
12	`1001 / 0 / 1`	`280`
13	`1001 / 1 / 0`	`250`
14	`1001 / 1 / 1`	`350`
15	`5000 / 0 / 0`	`180`
16	`5000 / 0 / 1`	`280`
17	`5000 / 1 / 0`	`250`
18	`5000 / 1 / 1`	`350`
19	`5001 / 0 / 0`	`300`
20	`5001 / 0 / 1`	`400`
21	`5001 / 1 / 0`	`400`
22	`10000 / 0 / 0`	`300`
23	`10000 / 0 / 1`	`400`
24	`10000 / 1 / 0`	`400`
25	`10000 / 1 / 1`	`500`

Тема 3 — Циклы

→Методическая карта темы

Комплект учителя. Не добавлять в ученическую навигацию и не прикреплять как условие работы.

Занятие	Теория	Практика
1 · повторения	for, range, границы, while как сравнение	C1, C2
2 · обработка данных	Счётчик, накопитель, if внутри цикла	C4 → C5 → C3 → C6; затем самостоятельные варианты C4 и C5
3 · условие окончания	while, сигнал, пустой ввод, цифры	C7–C10; затем самостоятельный вариант C8
По готовности	Сохранение состояния, максимум, серии	C11–C12

🧭

Как проверять понимание

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

Сохраняем номера файлов: C3 выполняется после C5, когда уже изучен счётчик. Мини-упражнения в теории: предсказание вывода, диапазон, выбор цикла, исправление накопителя, восстановление ввода. Анимация суммы позволяет сравнить правильный алгоритм с обнулением внутри тела.

C1Сигнал готовности

Проверяем: Понимание числа повторений, включая 0.

Один из возможных эталонов · c1.py

n=int(input())
for i in range(n):
    print("READY")

Ввод	Ожидаемый вывод
`0`	`(нет вывода)`
`1`	`READY`
`3`	`READY READY READY`
`20`	Развернуть тест: 20 строк READY READY READY READY READY READY READY READY READY READY READY READY READY READY READY READY READY READY READY READY

🔎

Типичный сбой

Лишняя строка при n=0; использование диапазона от 1 до n без включения n.

💬

Вопрос ученику

Число проходов совпадает с n? Что происходит при нулевом n?

C2Обратный отсчёт

Проверяем: Отрицательный шаг и исключённая граница.

Один из возможных эталонов · c2.py

n=int(input())
for i in range(n,0,-1):
    print(i)

Ввод	Ожидаемый вывод
`1`	`1`
`4`	`4 3 2 1`
`2`	`2 1`
`100`	Развернуть тест: 100 строк 100 99 98 97 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82 81 80 79 78 77 76 75 74 73 72 71 70 69 68 67 66 65 64 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1

🔎

Типичный сбой

range(n,1,-1) теряет 1; положительный шаг даёт пустой диапазон.

💬

Вопрос ученику

Какое первое и какое последнее значение?

C4Общая сумма измерений

Проверяем: Инициализация суммы до цикла и обработка n вводов.

Один из возможных эталонов · c4.py

n=int(input())
total=0
for i in range(n):
    total+=int(input())
print(total)

Ввод	Ожидаемый вывод
`0`	`0`
`3 4 -2 7`	`9`
`2 -3 -4`	`-7`
`1 0`	`0`
`4 5 -5 8 -8`	`0`
Развернуть тест: 101 строк 100 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000	`100000`

🔎

Типичный сбой

Сумма обнуляется в теле; итог print внутри тела.

💬

Вопрос ученику

Как меняется total после двух измерений?

Самостоятельный вариант: решение и проверка

Сумма чётных измерений

Сначала вводится n (0 ≤ n ≤ 100), затем n целых измерений от −1000 до 1000 на отдельных строках. Найди сумму только чётных измерений. Если подходящих нет, ответ 0. Сохрани как c4_extra.py.

n = int(input())
total = 0
for sample in range(n):
    value = int(input())
    if value % 2 == 0:
        total += value
print(total)

Ввод	Вывод
`4 4 -2 7 0`	`2`
`0`	`0`
`3 1 3 -5`	`0`
`3 -4 -2 6`	`0`

Вопрос ученику: Какие значения исключены из суммы? Как изменится решение, если нужны только нечётные?

C5Сколько положительных?

Проверяем: Условный счётчик и строгая положительность.

Один из возможных эталонов · c5.py

n=int(input())
count=0
for i in range(n):
    x=int(input())
    if x>0:
        count+=1
print(count)

Ввод	Ожидаемый вывод
`0`	`0`
`3 0 -2 0`	`0`
`5 -2 0 7 1 -1`	`2`
`4 1 2 3 4`	`4`
`1 -1`	`0`
Развернуть тест: 101 строк 100 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000	`100`

🔎

Типичный сбой

Ноль засчитан положительным; count растёт на каждом проходе.

💬

Вопрос ученику

Что произойдёт на отрицательном значении и на нуле?

Самостоятельный вариант: решение и проверка

Сколько измерений выше порога?

Вводятся n (0 ≤ n ≤ 100), затем целый порог threshold, затем n целых измерений. Порог и измерения лежат от −1000 до 1000. Каждое число на отдельной строке. Посчитай измерения строго больше threshold. Равные порогу не учитываются. Сохрани как c5_extra.py.

n = int(input())
threshold = int(input())
count = 0
for sample in range(n):
    value = int(input())
    if value > threshold:
        count += 1
print(count)

Ввод	Вывод
`4 5 5 7 -2 9`	`2`
`0 -3`	`0`
`3 -5 -5 -4 0`	`2`
`3 10 10 9 -1`	`0`

Вопрос ученику: Почему value == threshold не увеличивает счётчик? Где вводится порог и почему только один раз?

C3Чётные номера

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

Один из возможных эталонов · c3.py

a=int(input())
b=int(input())
count=0
for x in range(a,b+1):
    if x%2==0:
        print(x)
        count+=1
if count==0:
    print("NO")

Ввод	Ожидаемый вывод
`-3 3`	`-2 0 2`
`3 3`	`NO`
`2 2`	`2`
`0 0`	`0`
`-4 -2`	`-4 -2`
`1 4`	`2 4`
`-100 100`	Развернуть тест: 101 строк -100 -98 -96 -94 -92 -90 -88 -86 -84 -82 -80 -78 -76 -74 -72 -70 -68 -66 -64 -62 -60 -58 -56 -54 -52 -50 -48 -46 -44 -42 -40 -38 -36 -34 -32 -30 -28 -26 -24 -22 -20 -18 -16 -14 -12 -10 -8 -6 -4 -2 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98 100

🔎

Типичный сбой

Проверка только начала; не включён b; NO печатается для каждого нечётного.

💬

Вопрос ученику

NO относится к одному числу или всему диапазону?

C6Произведение от 1 до n

Проверяем: Произведение и нейтральное начальное значение.

Один из возможных эталонов · c6.py

n=int(input())
p=1
for x in range(1,n+1):
    p*=x
print(p)

Ввод	Ожидаемый вывод
`0`	`1`
`1`	`1`
`4`	`24`
`12`	`479001600`
`2`	`2`
`3`	`6`

🔎

Типичный сбой

Начальное значение 0; n не включено в range.

💬

Вопрос ученику

Почему произведение начинается с 1?

C7Числа до нуля

Проверяем: Сигнал окончания и количество обработанных данных.

Один из возможных эталонов · c7.py

x=int(input())
count=0
while x!=0:
    count+=1
    x=int(input())
print(count)

Ввод	Ожидаемый вывод
`0`	`0`
`5 -2 8 0`	`3`
`7 0`	`1`
`-5 -2 0`	`2`
Развернуть тест: 101 строк 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0	`100`

🔎

Типичный сбой

Сигнал засчитан; нет нового ввода в теле.

💬

Вопрос ученику

Где появляется следующее число? Когда оно уже не считается?

C8Сумма до сигнала

Проверяем: Накопление при неизвестном числе проходов.

Один из возможных эталонов · c8.py

x=int(input())
total=0
while x!=0:
    total+=x
    x=int(input())
print(total)

Ввод	Ожидаемый вывод
`0`	`0`
`5 -2 8 0`	`11`
`-2 -3 0`	`-5`
`7 0`	`7`
`5 -5 0`	`0`
Развернуть тест: 101 строк -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 -1000 0	`-100000`

🔎

Типичный сбой

В сумму включена служебная информация; сумма сбрасывается.

💬

Вопрос ученику

Какие числа являются данными, а какое — сигналом?

Самостоятельный вариант: решение и проверка

Сумма отрицательных до сигнала

Вводятся целые числа от −1000 до 1000 до первого 0; завершающий 0 обязателен. Каждое число на отдельной строке. Найди сумму только отрицательных чисел. Положительные пропускай, но продолжай чтение. Если отрицательных нет, ответ 0. Сохрани как c8_extra.py.

total = 0
value = int(input())
while value != 0:
    if value < 0:
        total += value
    value = int(input())
print(total)

Ввод	Вывод
`5 -2 8 -3 0`	`-5`
`0`	`0`
`1 2 0`	`0`
`-7 -3 0`	`-10`

Вопрос ученику: Почему следующий input должен выполняться и после положительного числа?

C9Достигни цели удвоением

Проверяем: Условие достижения цели и минимальность числа шагов.

Один из возможных эталонов · c9.py

target=int(input())
energy=1
steps=0
while energy<target:
    energy*=2
    steps+=1
print(steps)

Ввод	Ожидаемый вывод
`1`	`0`
`16`	`4`
`17`	`5`
`1000000000`	`30`
`2`	`1`
`3`	`2`
`15`	`4`
`536870912`	`29`
`536870913`	`30`

🔎

Типичный сбой

Лишний шаг при точной степени двойки; старт не равен 1.

💬

Вопрос ученику

Нужно строго превысить цель или достаточно равенства?

C10Количество цифр

Проверяем: Целочисленное уменьшение числа и особый случай 0.

Один из возможных эталонов · c10.py

n=int(input())
count=0
if n==0:
    count=1
while n>0:
    count+=1
    n//=10
print(count)

Ввод	Ожидаемый вывод
`0`	`1`
`7`	`1`
`1005`	`4`
`1000000000`	`10`
`9`	`1`
`10`	`2`
`99`	`2`
`100`	`3`
`999999999`	`9`

🔎

Типичный сбой

Обычное деление вместо //; ответ 0 для числа 0.

💬

Вопрос ученику

Сколько цифр в записи нуля? Чем отличается это от суммы цифр?

C11Максимум последовательности

Проверяем: Максимум, отрицательные данные и пустая последовательность.

Один из возможных эталонов · c11.py

x=int(input())
if x==0:
    print("EMPTY")
else:
    best=x
    while x!=0:
        if x>best:
            best=x
        x=int(input())
    print(best)

Ввод	Ожидаемый вывод
`0`	`EMPTY`
`-8 -3 -10 0`	`-3`
`5 0`	`5`
`-5 7 0`	`7`
`1 4 9 0`	`9`
`9 4 1 0`	`9`
`2 9 3 0`	`9`
`-5 -1 0`	`-1`
`7 7 0`	`7`
`-1000 1000 -999 0`	`1000`

🔎

Типичный сбой

Максимум начинается с 0, поэтому отрицательные данные теряются.

💬

Вопрос ученику

Как выбрать начальный максимум, если все данные могут быть отрицательными?

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

C12Самая длинная серия плюсов

Проверяем: Текущая серия и лучший результат как разные состояния.

Один из возможных эталонов · c12.py

x=int(input())
run=0
best=0
while x!=0:
    if x>0:
        run+=1
        if run>best:
            best=run
    else:
        run=0
    x=int(input())
print(best)

Ввод	Ожидаемый вывод
`0`	`0`
`-2 -1 0`	`0`
`1 2 3 0`	`3`
`2 3 -1 4 5 6 -2 0`	`3`
`1 2 3 -1 4 0`	`3`
`1 2 3 -1 4 -2 0`	`3`
`1 -1 2 -2 3 0`	`1`
`1 2 -1 3 4 0`	`2`
`5 0`	`1`
`-1 2 3 0`	`2`
Развернуть тест: 101 строк 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0	`100`

🔎

Типичный сбой

Лучшее значение стирается при отрицательном числе; последняя серия не учтена.

💬

Вопрос ученику

Что означает каждая переменная и что должно сохраниться после разрыва серии?

Дополнительная диагностика: текущая серия может стать короче лучшей. На вводе 1, 2, 3, −1, 4, 0 ответ 3, а не 1. Обновляй best только при улучшении результата.

Тема 4 — Строки

Методическая карта

Комплект продолжает курс 7 класса: ввод → условия → циклы → строки. Он рассчитан на учеников, которые запускали .py в IDLE, знакомы с if, and, for и счётчиком. Фактическое усвоение предыдущих тем нужно проверить в начале. Длительности ниже — методическая оценка, не результат наблюдения за классом.

Урок	Примерный ход, 45 минут	Результат
1	5 мин диагностика → 8 мин строка/метод/неизменяемость → 12 мин регистр, strip, replace → 15 мин D1–D3 → 5 мин обсуждение	Ученик сохраняет результат, различает очистку краёв и замену
2	5 мин повторение → 10 мин поиск/подсчёт → 10 мин проверки состава и границ → 15 мин выбор D4–D8 → 5 мин выходной вопрос	Различает наличие, позицию и количество; проверяет 0 и −1
3	5 мин повторение → 7 мин список как результат → 10 мин split/join → 18 мин D9–D12 по темпу → 5 мин разбор	Называет тип результата и выбирает явный разделитель

Все 16 задач не нужно успевать за три урока. На уроке 2 минимум: D4, D5, D6, D7; D8 — закрепление или следующий урок. На уроке 3 минимум: D9 и D10; D11–D12 — закрепление. D13–D16 — резерв для сильных учеников, домашнего задания или дополнительного занятия.

Показывай приём «предскажи → запусти → измени один параметр → объясни». Перед готовой цепочкой методов сначала разложи её на переменные. Не превращай задачу в соревнование по длине выражения.

Диагностика и критерии

В начале: спроси тип результата input(), предложи сохранить "0072", попроси объяснить if и счётчик. Перед третьим занятием отдельно объясни список и два уровня индексов в parts[0][0].

Уровень освоения	Наблюдаемый признак
Нужно вернуться к основе	Вызывает s.lower без (), теряет результат, преобразует код в int
Базовый	Правильно решает задачу на один метод и обычный пример
Уверенный	Выбирает метод по смыслу, проверяет крайний случай и объясняет тип
Расширенный	Комбинирует методы и цикл; сам находит контрпример к неверному решению

Для выбранной заранее задачи можно использовать 0–3 учебных балла: 1 — правильный алгоритм на обычных данных; 1 — соблюдён формат и разобраны особые случаи; 1 — ученик объяснил выбор метода и предложил собственный тест. Это рекомендованная локальная рубрика, а не настроенная отметка в журнале. Объём и критерии объяви до начала работы.

Не оценивай количество изученных методов само по себе. При эквивалентном корректном решении попроси отдельно продемонстрировать нужный метод на коротком примере. Набор D1–D16 подключён к тренировочной автопроверке: можно отправлять часть задач; значимые пробелы и пустые строки учитываются. Автоматическая отметка ученику не выставляется.

Ответы к самопроверке

№	Ответ	Почему
1	Кот	Метод вернул новую строку, но результат не присвоен. Исходная переменная хранит «Кот».
2	"a b"	strip убирает пробельные символы по краям. Внутренние два пробела останутся.
3	0	Первый индекс равен 0. Поэтому if s.find(...) использовать нельзя.
4	−1	find возвращает −1 при отсутствии. index в такой ситуации вызовет ValueError.
5	2	count считает неперекрывающиеся вхождения: aa + aa.
6	name.endswith(".py")	endswith проверяет конец. in принимает и task.py.txt; startswith проверяет начало.
7	False	Для isdigit, isalpha, isalnum и isspace пустая строка даёт False.
8	["a", "b"]	Без явного разделителя split объединяет пробельные промежутки; результат — список.
9	4	Явный разделитель сохраняет пустые поля: ["a", "", "b", ""].
10	"-".join(parts)	join вызывают у строки-разделителя. Элементы parts должны быть строками.

D1. Имя команды

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

Вывод. Обработанное название. Если оно пустое, выведи пустую строку.

Целевые приёмы: strip, lower

d1.py · эталон

s = input()
print(s.strip().lower())

Проверочные данные

Кавычки обозначают запись текста, а не часть ввода/вывода; \n — переход строки, \t — табуляция.

Ввод, repr	Ожидаемый вывод, repr
`' PyThOn '`	`'python'`
`' Красный Робот '`	`'красный робот'`
`''`	`''`
`' '`	`''`
`'БОТ7'`	`'бот7'`
`'a'`	`'a'`

Типичные ошибки. Удаление всех пробелов через replace меняет внутренние промежутки. Вызов методов без сохранения теряет результат.

Вопрос ученику. Почему strip подходит лучше, чем replace(" ", "")?

D2. Расшифруй сообщение

Задача. Вводится строка сообщения. Все символы подчёркивания _ обозначают пробелы. Замени каждое подчёркивание одним обычным пробелом; остальные символы сохрани.

Вывод. Расшифрованное сообщение; число пробелов после замены не сокращай.

Целевые приёмы: replace

d2.py · эталон

s = input()
print(s.replace("_", " "))

Проверочные данные

Кавычки обозначают запись текста, а не часть ввода/вывода; \n — переход строки, \t — табуляция.

Ввод, repr	Ожидаемый вывод, repr
`'Робот_готов'`	`'Робот готов'`
`'A__B'`	`'A B'`
`''`	`''`
`'___'`	`' '`
`'робот'`	`'робот'`
`'_x_'`	`' x '`

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

Вопрос ученику. Как изменится решение, если заменить нужно только первое подчёркивание?

D3. Табличка на дверь

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

Вывод. Текст таблички после трёх преобразований.

Целевые приёмы: strip, upper, replace

d3.py · эталон

s = input().strip().upper()
print(s.replace(" ", "-", 1))

Проверочные данные

Кавычки обозначают запись текста, а не часть ввода/вывода; \n — переход строки, \t — табуляция.

Ввод, repr	Ожидаемый вывод, repr
`' кабинет робототехники '`	`'КАБИНЕТ-РОБОТОТЕХНИКИ'`
`'клуб юных роботов'`	`'КЛУБ-ЮНЫХ РОБОТОВ'`
`' '`	`''`
`'робот'`	`'РОБОТ'`
`'a b'`	`'A- B'`
`' x '`	`'X'`

Типичные ошибки. Замена всех пробелов вместо одного; вызов replace до strip.

Вопрос ученику. Почему здесь важен порядок операций?

D4. Упоминания робота

Задача. Вводится строка. Посчитай неперекрывающиеся вхождения подстроки «робот» без учёта регистра. Вхождение внутри длинного слова тоже учитывается; искать отдельные слова не требуется.

Вывод. Одно целое число — число вхождений.

Целевые приёмы: lower, count

d4.py · эталон

s = input()
print(s.lower().count("робот"))

Проверочные данные

Кавычки обозначают запись текста, а не часть ввода/вывода; \n — переход строки, \t — табуляция.

Ввод, repr	Ожидаемый вывод, repr
`'Робот и РОБОТ'`	`'2'`
`'робототехника'`	`'1'`
`''`	`'0'`
`'кот'`	`'0'`
`'роботробот'`	`'2'`
`'РОБОТОТЕХНИКА робот'`	`'2'`

Типичные ошибки. split меняет задачу на поиск целого слова. Только lower без count не даёт количество.

Вопрос ученику. Чем эта задача отличается от подсчёта слова «робот»?

D5. Где собачка?

Задача. Вводится строка. Найди индекс первого символа @, считая позиции с нуля. Если такого символа нет, выведи −1. Это задача о поиске символа, а не о проверке настоящего адреса почты.

Вывод. Индекс первого @ или −1.

Целевые приёмы: find

d5.py · эталон

s = input()
print(s.find("@"))

Проверочные данные

Кавычки обозначают запись текста, а не часть ввода/вывода; \n — переход строки, \t — табуляция.

Ввод, repr	Ожидаемый вывод, repr
`'user@mail.ru'`	`'4'`
`'@robot'`	`'0'`
`'robot'`	`'-1'`
`''`	`'-1'`
`'a@b@c'`	`'1'`
`'я@дом'`	`'1'`

Типичные ошибки. index вызывает исключение при отсутствии. if s.find("@") путает 0 и −1.

Вопрос ученику. Почему индекс 0 — корректный ответ, а не отсутствие?

D6. Python-файл

Задача. Вводится имя файла. Удали пробельные края, затем проверь, заканчивается ли имя на .py без учёта регистра. В этой учебной задаче других требований к имени нет.

Вывод. YES, если условие выполнено, иначе NO.

Целевые приёмы: strip, lower, endswith

d6.py · эталон

name = input().strip().lower()
if name.endswith(".py"):
    print("YES")
else:
    print("NO")

Проверочные данные

Кавычки обозначают запись текста, а не часть ввода/вывода; \n — переход строки, \t — табуляция.

Ввод, repr	Ожидаемый вывод, repr
`' Lesson.PY '`	`'YES'`
`'task.py.txt'`	`'NO'`
`''`	`'NO'`
`'.py'`	`'YES'`
`'spy'`	`'NO'`
`'a.Py'`	`'YES'`
`' x.py '`	`'YES'`

Типичные ошибки. Проверка через in принимает task.py.txt. Проверка без точки принимает spy.

Вопрос ученику. Какой тест отличает endswith от in?

D7. Код пропуска

Задача. Вводится строка из латинских/русских букв, обычных цифр 0–9, пробелов и знаков ASCII. Других символов-цифр Unicode во входе нет. Корректный код содержит ровно четыре цифры 0–9. Пробелы не удаляй. Ведущие нули разрешены.

Вывод. YES для корректного кода, иначе NO.

Целевые приёмы: len, isdigit

d7.py · эталон

s = input()
if len(s) == 4 and s.isdigit():
    print("YES")
else:
    print("NO")

Проверочные данные

Кавычки обозначают запись текста, а не часть ввода/вывода; \n — переход строки, \t — табуляция.

Ввод, repr	Ожидаемый вывод, repr
`'0072'`	`'YES'`
`' 072'`	`'NO'`
`'123'`	`'NO'`
`'12345'`	`'NO'`
`''`	`'NO'`
`'-123'`	`'NO'`
`'12a4'`	`'NO'`
`'0000'`	`'YES'`
`' 0072 '`	`'NO'`
`'\t1234'`	`'NO'`

Типичные ошибки. int теряет ведущие нули. strip незаконно принимает код с пробелами.

Вопрос ученику. Почему в условии отдельно указан алфавит цифр?

D8. Учебный логин

Задача. Вводится строка. Сначала убери пробельные края. Логин допустим, если его длина от 3 до 12 включительно, в нём только буквы, цифры и подчёркивания _, а также есть хотя бы одна буква или цифра. Буквы/цифры понимаются так же, как в isalnum(). Внутренние пробелы запрещены.

Вывод. YES для допустимого логина, иначе NO.

Целевые приёмы: strip, replace, isalnum, len

d8.py · эталон

s = input().strip()
if 3 <= len(s) <= 12 and s.replace("_", "").isalnum():
    print("YES")
else:
    print("NO")

Проверочные данные

Кавычки обозначают запись текста, а не часть ввода/вывода; \n — переход строки, \t — табуляция.

Ввод, repr	Ожидаемый вывод, repr
`' bot_7 '`	`'YES'`
`'___'`	`'NO'`
`'я_7'`	`'YES'`
`'a_'`	`'NO'`
`'a b'`	`'NO'`
`'a-b'`	`'NO'`
`'abcdefghijkl'`	`'YES'`
`'abcdefghijklm'`	`'NO'`
`''`	`'NO'`
`'___a'`	`'YES'`

Типичные ошибки. Проверка длины после удаления _ меняет правило; чистый isalnum отвергает разрешённое подчёркивание.

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

D9. Сколько слов?

Задача. Вводится строка. Словом считаем каждый элемент разбиения по пробельным промежуткам: знаки препинания остаются частью слова. Посчитай слова; строка может быть пустой или состоять из пробелов.

Вывод. Число слов.

Целевые приёмы: split, len

d9.py · эталон

s = input()
print(len(s.split()))

Проверочные данные

Кавычки обозначают запись текста, а не часть ввода/вывода; \n — переход строки, \t — табуляция.

Ввод, repr	Ожидаемый вывод, repr
`' робот едет домой '`	`'3'`
`' '`	`'0'`
`''`	`'0'`
`'Привет, мир!'`	`'2'`
`'слово'`	`'1'`
`'a\tb'`	`'2'`

Типичные ошибки. count(" ")+1 даёт неправильный ответ на повторных пробелах и пустом тексте.

Вопрос ученику. Почему длина исходной строки здесь не подходит?

D10. Адрес страницы кружка

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

Вывод. Строка со словами через дефис без дефисов по краям.

Целевые приёмы: lower, split, join

d10.py · эталон

s = input()
words = s.lower().split()
print("-".join(words))

Проверочные данные

Кавычки обозначают запись текста, а не часть ввода/вывода; \n — переход строки, \t — табуляция.

Ввод, repr	Ожидаемый вывод, repr
`' Клуб Роботов '`	`'клуб-роботов'`
`'Python'`	`'python'`
`''`	`''`
`' '`	`''`
`'КОД И РОБОТЫ'`	`'код-и-роботы'`
`'Клуб, Робот!'`	`'клуб,-робот!'`

Типичные ошибки. replace(" ", "-") оставит повторные дефисы; words.lower() вызывает метод у списка.

Вопрос ученику. Назови тип результата после lower, split и join.

D11. Заполненные поля

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

Вывод. Количество заполненных полей.

Целевые приёмы: split с разделителем, strip, for

d11.py · эталон

s = input()
count = 0
for field in s.split(";"):
    if field.strip() != "":
        count += 1
print(count)

Проверочные данные

Кавычки обозначают запись текста, а не часть ввода/вывода; \n — переход строки, \t — табуляция.

Ввод, repr	Ожидаемый вывод, repr
`'робот;; датчик ; ;мотор;'`	`'3'`
`' ; ; '`	`'0'`
`''`	`'0'`
`'a;b'`	`'2'`
`'a b'`	`'1'`
`';;;'`	`'0'`
`'; x ;'`	`'1'`

Типичные ошибки. len(split(";")) считает пустые поля тоже. strip только всей строки не очищает отдельные поля.

Вопрос ученику. Чем «число полей» отличается от «числа заполненных полей»?

D12. Подпись участника

Задача. Вводится имя и фамилия — ровно два непустых слова из букв в правильном регистре, например «Анна Петрова». Между словами и по краям может быть несколько пробелов. Выведи фамилию, пробел, первую букву имени в верхнем регистре и точку. Гарантируется наличие двух слов.

Вывод. Подпись в формате Фамилия И.

Целевые приёмы: split, индексы, upper

d12.py · эталон

parts = input().split()
print(parts[1] + " " + parts[0][0].upper() + ".")

Проверочные данные

Кавычки обозначают запись текста, а не часть ввода/вывода; \n — переход строки, \t — табуляция.

Ввод, repr	Ожидаемый вывод, repr
`'Анна Петрова'`	`'Петрова А.'`
`' иван Иванов '`	`'Иванов И.'`
`'Ёлка Ёжова'`	`'Ёжова Ё.'`
`'А Б'`	`'Б А.'`
`'Марк Ли'`	`'Ли М.'`

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

Вопрос ученику. Какая гарантия входа позволяет здесь не проверять длину списка?

D13. Расширение после последней точки

Задача. Вводится только имя файла, без пути. Удали пробельные края и найди последнюю точку. Расширением считаем непустой фрагмент после неё, если перед ней есть хотя бы один символ. Если последняя точка стоит первой или последней либо точек нет, расширения нет. Это учебное правило, не полный разбор файловых систем.

Вывод. Расширение в нижнем регистре либо NO.

Целевые приёмы: strip, rfind, срез, lower

d13.py · эталон

name = input().strip()
pos = name.rfind(".")
if 0 < pos < len(name) - 1:
    print(name[pos + 1:].lower())
else:
    print("NO")

Проверочные данные

Кавычки обозначают запись текста, а не часть ввода/вывода; \n — переход строки, \t — табуляция.

Ввод, repr	Ожидаемый вывод, repr
`'archive.tar.GZ'`	`'gz'`
`'.env'`	`'NO'`
`'file.'`	`'NO'`
`'README'`	`'NO'`
`''`	`'NO'`
`' x.PY '`	`'py'`
`'.config.py'`	`'py'`
`'a..TXT'`	`'txt'`

Типичные ошибки. find вернёт первую точку. Отсутствие проверки −1 может превратить всё имя в расширение.

Вопрос ученику. Почему archive.tar.gz нужно проверять отдельно от file.py?

D14. Команда учебного бота

Задача. Вводится команда, возможно с аргументами после пробелов. Выдели первое слово по пробельным промежуткам и сравни его без учёта регистра. Для /start выведи START, для /stop — STOP, для любого другого слова либо пустого ввода — UNKNOWN. /starter не является /start.

Вывод. Одна строка: START, STOP или UNKNOWN.

Целевые приёмы: split, lower, if

d14.py · эталон

parts = input().split()
if len(parts) == 0:
    print("UNKNOWN")
else:
    command = parts[0].lower()
    if command == "/start":
        print("START")
    elif command == "/stop":
        print("STOP")
    else:
        print("UNKNOWN")

Проверочные данные

Кавычки обозначают запись текста, а не часть ввода/вывода; \n — переход строки, \t — табуляция.

Ввод, repr	Ожидаемый вывод, repr
`' /START робот'`	`'START'`
`'/starter'`	`'UNKNOWN'`
`'/stop'`	`'STOP'`
`''`	`'UNKNOWN'`
`' '`	`'UNKNOWN'`
`'/stopper'`	`'UNKNOWN'`
`'привет /start'`	`'UNKNOWN'`
`'/StOp x'`	`'STOP'`

Типичные ошибки. startswith("/start") принимает /starter. Без проверки пустого списка возникнет IndexError.

Вопрос ученику. Почему startswith здесь даёт слишком широкий результат?

D15. Очищенный список тегов

Задача. Вводится строка тегов, разделённых запятыми. Для каждого поля убери пробельные края, переведи буквы в нижний регистр и выведи непустые теги по одному на строке. Порядок и повторы сохрани; внутренние пробелы не меняй. Если непустых тегов нет, выведи EMPTY.

Вывод. Обработанные непустые теги, каждый на новой строке, либо EMPTY.

Целевые приёмы: split, strip, lower, for

d15.py · эталон

s = input()
count = 0
for field in s.split(","):
    tag = field.strip().lower()
    if tag != "":
        print(tag)
        count += 1
if count == 0:
    print("EMPTY")

Проверочные данные

Кавычки обозначают запись текста, а не часть ввода/вывода; \n — переход строки, \t — табуляция.

Ввод, repr	Ожидаемый вывод, repr
`' Python, , РОБОТ,python,'`	`'python\nробот\npython'`
`' , , '`	`'EMPTY'`
`''`	`'EMPTY'`
`'КРАСНЫЙ РОБОТ'`	`'красный робот'`
`'a,A'`	`'a\na'`
`',x,'`	`'x'`

Типичные ошибки. set незаконно удалит повторы; split() потеряет заданное деление по запятым; lower до очистки не уберёт пробелы.

Вопрос ученику. Какие два теста проверяют сохранение повторов и внутренних пробелов?

D16. Анализ строки без пробельных символов

Задача. Вводится строка. Удали из неё все пробельные символы, соединив элементы split() пустой строкой, и переведи буквы в нижний регистр. Если результат пустой, выведи EMPTY. Иначе проверь, читается ли он одинаково слева направо и справа налево. Знаки препинания сохраняются и участвуют в сравнении.

Вывод. YES, если непустой результат симметричен, NO в остальных непустых случаях, EMPTY для пустого результата.

Целевые приёмы: split, join, lower, срез

d16.py · эталон

s = "".join(input().split()).lower()
if s == "":
    print("EMPTY")
elif s == s[::-1]:
    print("YES")
else:
    print("NO")

Проверочные данные

Кавычки обозначают запись текста, а не часть ввода/вывода; \n — переход строки, \t — табуляция.

Ввод, repr	Ожидаемый вывод, repr
`'А роза упала на лапу Азора'`	`'YES'`
`'робот'`	`'NO'`
`' '`	`'EMPTY'`
`''`	`'EMPTY'`
`'A'`	`'YES'`
`'А, роза упала на лапу Азора'`	`'NO'`
`'А\tа'`	`'YES'`
`'!'`	`'YES'`

Типичные ошибки. strip удалит пробелы только по краям. Удаление знаков препинания изменит правило задачи.

Вопрос ученику. Почему симметричность пустой строки по условию не даёт YES?