break и continue, чтение чужого кода, вложенные циклы

Перебирать делители надо по возрастанию — тогда первый же найденный и будет наименьшим.

Само число тоже делитель: у простого числа других и нет, поэтому перебор должен доходить до n включительно.

1. Идём по числам от 2 до n включительно.
2. Первое же, на которое n делится нацело, печатаем.
3. И сразу выходим из цикла: остальные делители нас не интересуют.

n = int(input())

for d in range(2, n + 1):
    if n % d == 0:
        print(d)
        break        # первый найденный делитель и есть наименьший

Без break программа напечатала бы все делители подряд. Именно порядок перебора — от меньшего к большему — делает первый найденный ответом; будь перебор обратным, break дал бы наибольший делитель.

Каждый запрещённый участок — это цепочка сравнений вроде 5 <= i <= 9.

Число пропускается, если попало хотя бы в один участок, — значит, связка or.

1. Перебираем все числа от 1 до n.
2. Если число попало в любой из трёх промежутков — continue, и печать не выполняется.
3. Иначе печатаем.

n = int(input())

for i in range(1, n + 1):
    if 5 <= i <= 9 or 17 <= i <= 37 or 78 <= i <= 87:
        continue      # запрещённое число — сразу к следующему шагу
    print(i)

Без continue пришлось бы писать условие наоборот, целиком под not, и печатать внутри него. Так короче, а главное — видно, что именно исключается.

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

Самая коварная ошибка — в условии: i — это номер шага, а чётность нужна у самого числа.

1. s = 1 — сумма обязана начинаться с нуля, иначе ответ всегда на единицу больше.
2. range(1, 7) даёт шесть шагов, а чисел семь: нужен range(7).
3. n = input() возвращает строку — сложение с ней даст ошибку; нужен int().
4. if i % 2 == 0 проверяет чётность номера шага, а не числа: нужно n % 2 == 0.

s = 0                    # было s = 1: сумма начинается с нуля
for i in range(7):       # было range(1, 7): чисел семь, а не шесть
    n = int(input())     # было input(): нужно число, а не строка
    if n % 2 == 0:       # было i % 2: чётность проверяем у числа, а не у номера шага
        s = s + n
print(s)

Три ошибки из четырёх программа выдала бы сама — упала бы или выдала явную чушь. А вот i % 2 вместо n % 2 не ломает ничего: программа считает и печатает правдоподобное число. Такие ошибки находятся только чтением кода или проверкой на примере, где ответ известен заранее.

Первая строка ломает программу сразу: сравнить строку с числом Python не сможет.

Возьмите число 234 и пройдите цикл по шагам. Все ли цифры попали в произведение?

1. n = input() даёт строку — нужен int().
2. Условие n >= 10 обрывает цикл, когда осталась одна цифра, — и старшая цифра в произведение не попадает. У числа 234 получилось бы 12 вместо 24.
3. Правильное условие — while n > 0: цикл доходит до последней цифры.
4. Однозначное число при этом тоже обрабатывается верно — со старым условием цикл для него не выполнялся ни разу, и программа печатала единицу.

n = int(input())     # было input(): нужно число
product = 1
while n > 0:         # было n >= 10: так терялась старшая цифра
    digit = n % 10   # последняя цифра
    product = product * digit
    n //= 10         # отбрасываем её и идём дальше
print(product)

Проверять такие программы удобно на числе, у которого цифры разные и ответ считается в уме: 234 → 24. На числе 123 обе версии дают 6, и ошибка не видна — старшая цифра там единица, а умножение на единицу ничего не меняет.

Чтобы добраться до старшей цифры, число надо укорачивать справа. Какая операция это делает — остаток или деление нацело?

Останавливаться надо, пока цифра ещё осталась. При условии n > 0 цикл доработает до нуля — и напечатает ноль.

1. n %= 10 оставляет последнюю цифру, а нужно наоборот — отбросить её: n //= 10.
2. С условием n > 0 цикл дойдёт до нуля, и вся первая цифра потеряется. Останавливаться надо, когда число стало однозначным: while n >= 10.
3. После цикла в n остаётся ровно старшая цифра.

n = int(input())
while n >= 10:       # было n > 0: цикл доходил до нуля
    n //= 10         # было n %= 10: отбрасываем последнюю цифру
print(n)

Обратите внимание, что первая версия ещё и зацикливалась бы: n %= 10 у однозначного числа не меняет его вовсе, и условие n > 0 оставалось бы истинным вечно. Две ошибки здесь чинят друг друга по-разному, поэтому искать их надо обе.

Две ошибки — арифметические (с чего начинается произведение и сколько чисел читается), две — смысловые (что считать неотрицательным и что печатать).

«Неотрицательное» — это не то же самое, что «положительное»: ноль тоже неотрицателен.

1. p = 0 — произведение с нуля так и останется нулём; начальное значение должно быть 1.
2. range(1, 10) даёт девять шагов, а чисел десять: нужен range(10).
3. if x > 0 пропускает ноль, а он неотрицателен: нужно x >= 0.
4. print(x) печатает последнее прочитанное число вместо количества: нужно print(count).

count = 0
p = 1                    # было p = 0: произведение начинается с единицы
for i in range(10):      # было range(1, 10): чисел десять
    x = int(input())
    if x >= 0:           # было x > 0: ноль тоже неотрицателен
        p = p * x
        count = count + 1

if count > 0:
    print(count)         # было print(x): печатать надо количество
    print(p)
else:
    print('NO')

Третий пример проверяет как раз спорное место: единственный ноль в наборе — это одно неотрицательное число и произведение, равное нулю. Программа с x > 0 ответила бы «NO» и была бы неправа.

Внешний цикл считает строки, внутренний — числа в строке.

Чтобы числа печатались в одну строку, нужен end=' ', а перевод строки — отдельной командой print() после внутреннего цикла.

1. Внешний цикл повторяется n раз — по числу строк.
2. Внутренний три раза печатает n с пробелом вместо перевода строки.
3. После внутреннего цикла — пустой print(), чтобы перейти на новую строку.

n = int(input())

for i in range(n):          # строки
    for j in range(3):      # числа в строке
        print(n, end=' ')
    print()                 # перевод строки после каждой строки таблицы

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

Отличие от предыдущей задачи только в том, что печатается: не n, а номер строки.

Чтобы номера шли с единицы, задайте range(1, n + 1).

1. Внешний цикл идёт по номерам строк от 1 до n.
2. Внутренний пять раз печатает этот номер.
3. Перевод строки — после внутреннего цикла.

n = int(input())

for i in range(1, n + 1):   # номер строки — он же печатаемое число
    for j in range(5):
        print(i, end=' ')
    print()

Здесь впервые пригодилась переменная внешнего цикла: в прошлой задаче i был просто счётчиком повторений, а тут он попал в вывод.

Всего строк n, и самая длинная — посередине. Сколько в ней звёздочек?

У основания 5 середина равна 3, у основания 7 — 4. Это (n + 1) // 2.

1. Считаем высоту пика: (n + 1) // 2.
2. Первый цикл печатает строки от одной звёздочки до пика.
3. Второй — от «пик минус один» обратно до одной.

n = int(input())
top = (n + 1) // 2          # самая длинная строка — посередине

for i in range(1, top + 1):     # растём
    print('*' * i)

for i in range(top - 1, 0, -1): # и убываем, не повторяя пик
    print('*' * i)

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

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

Знаки + и = — это текст в кавычках; пробелы вокруг них print() поставит сам.

1. Цикл идёт по второму слагаемому: от 1 до 9.
2. На каждом шаге печатаем пять значений: n, знак, слагаемое, знак равенства и сумму.

n = int(input())

for j in range(1, 10):
    print(n, '+', j, '=', n + j)

Сумму считаем прямо в print() — заводить для неё переменную незачем. А вот пробелы вокруг знаков лучше не дописывать руками: print() уже разделяет значения пробелом.

Это предыдущая задача, обёрнутая ещё одним циклом.

Пустая строка между блоками — это print() без аргументов после внутреннего цикла.

1. Внешний цикл идёт по первому слагаемому: от 1 до n.
2. Внутренний — по второму: от 1 до 9.
3. После внутреннего цикла печатаем пустую строку, отделяя блок от следующего.

n = int(input())

for i in range(1, n + 1):       # первое слагаемое
    for j in range(1, 10):      # второе
        print(i, '+', j, '=', i + j)
    print()                     # пустая строка между блоками

Всего строк получится 9n плюс разделители — вот и вся арифметика вложенных циклов: шаги перемножаются. При n = 9 таблица займёт 81 строку.

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

Но умножать надо строку, а не число: 5 * 5 даст 25, а не «55555».

1. Цикл идёт по номерам строк от 1 до n.
2. Превращаем номер в строку функцией str().
3. Умножаем эту строку на номер и печатаем.

n = int(input())

for i in range(1, n + 1):
    print(str(i) * i)       # str(i) — строка, поэтому умножение повторяет её

Тут видна разница между числом и строкой из тех же цифр: str(3) * 3 — это «333», а 3 * 3 — это 9. Одна и та же запись * делает два совершенно разных дела в зависимости от типа.