Программирование алгоритмов на языке программирования Python

Разбор темы

Алгоритм, его свойства и блок-схемы 5–8 класс

Алгоритм — это конечная последовательность точных команд, выполнение которых приводит к результату. Исполнитель (человек, робот, компьютер) выполняет команды формально, не задумываясь об их смысле.

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

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

Фигуры блок-схемы: овал (скруглённый прямоугольник) — «Начало» и «Конец»; параллелограмм — ввод и вывод данных; прямоугольник — действие (вычисление, присваивание); ромб — проверка условия, из него выходят две стрелки «да» и «нет»; шестиугольник — заголовок цикла с параметром (цикл for); прямоугольник с двойными боковыми линиями — вызов подпрограммы.

Базовые алгоритмические структуры: линейная (следование) — команды выполняются одна за другой; ветвление — выбор одного из путей по условию (в блок-схеме ромб, пути потом сходятся); цикл — повторение действий (в блок-схеме стрелка возвращается назад к условию). Любой алгоритм строится из этих трёх структур.

Переменные, типы данных, ввод и вывод 6 класс

Переменная создаётся присваиванием: x = 5. Знак = означает «положить значение справа в переменную слева», а не равенство. Запись x = x + 1 увеличивает x на 1 (кратко: x += 1). Имена: латинские буквы, цифры и _, не начинаются с цифры, регистр важен (A и a — разные переменные), нельзя использовать служебные слова (if, for, while...).

Основные типы: int — целые числа (5, -12, 0), float — вещественные (3.14, 2.0, 1e3), str — строки в кавычках ('hi', "5"), bool — логические True и False. Узнать тип: type(x). Python сам определяет тип по значению (динамическая типизация).

Множественное присваивание: a, b = 3, 7. Обмен значений без третьей переменной: a, b = b, a. Классический способ с третьей переменной: t = a; a = b; b = t.

Ввод: input() всегда возвращает строку. Поэтому для чисел: n = int(input()), x = float(input()). Несколько чисел в одной строке: a, b = map(int, input().split()).

Вывод: print(a, b, c) печатает значения через пробел и переходит на новую строку. Параметр sep задаёт разделитель между значениями, end — что печатается в конце (по умолчанию перенос строки '\n').

print(1, 2, 3, sep='-')        # 1-2-3
print('a', end='')
print('b')                     # ab
print(5, 6, sep='', end='!')   # 56!

print() без аргументов выводит пустую строку. f-строки: print(f'x = {x}') подставляет значение переменной в текст.

Арифметические операции, приоритет и преобразование типов 6–7 класс

Операции: +, -, *; / — обычное деление, результат всегда float (6 / 2 = 3.0); // — целочисленное деление (округление вниз, к меньшему числу); % — остаток от деления; ** — возведение в степень.

Примеры: 17 // 5 = 3, 17 % 5 = 2, 2 ** 10 = 1024. С отрицательными числами // округляет вниз: -17 // 5 = -4 (а не -3!), -17 % 5 = 3 (остаток имеет знак делителя). 7.5 // 2 = 3.0 — если один операнд float, результат тоже float.

Приоритет (от высшего к низшему): скобки () → ** → унарный минус -x → *, /, //, % → +, - → сравнения <, >, ==, !=, <=, >= → not → and → or. Операции одного приоритета выполняются слева направо, кроме **, которая выполняется справа налево: 2 ** 3 ** 2 = 2 ** 9 = 512. Также -2 ** 2 = -4, потому что степень старше минуса.

Пример расчёта: 2 + 3 * 4 ** 2 // 5 → сначала 4 ** 2 = 16, затем слева направо 3 * 16 = 48, 48 // 5 = 9, и наконец 2 + 9 = 11.

Преобразование типов: int('12') = 12; int(3.99) = 3 и int(-3.99) = -3 — дробная часть просто отбрасывается (к нулю); float('2.5') = 2.5; str(7) = '7'; round(3.5) = 4, но round(2.5) = 2 (Python округляет «половинки» к чётному). bool(0), bool(''), bool([]) — False, любое ненулевое число и непустая строка (даже '0') — True.

Строки тоже «складываются» и «умножаются»: '2' + '3' = '23' (склейка), 'ab' * 3 = 'ababab'. Но '2' + 3 — ошибка TypeError: строку и число складывать нельзя.

Полезные встроенные функции: abs(x) — модуль, max(a, b, c) и min(...), round(x, 2) — округление до 2 знаков, len(s) — длина. Модуль math: import math, math.sqrt(16) = 4.0, math.ceil(2.1) = 3, math.floor(2.9) = 2.

Ветвление: if, elif, else; логические операции 7 класс

Структура: после if условие: ставится двоеточие, тело пишется с отступом в 4 пробела. Ветка elif (иначе если) проверяется, только если все предыдущие условия ложны; else выполняется, если ложны все. Из всей цепочки выполняется ровно одна ветка (или ни одной, если нет else).

if score >= 90:
    grade = 5
elif score >= 75:
    grade = 4
elif score >= 50:
    grade = 3
else:
    grade = 2

Порядок elif важен: при score = 95 сработает первая ветка, хотя 95 >= 75 тоже верно. Если бы проверки шли от меньшего к большему (сначала >= 50), все хорошие оценки ошибочно стали бы тройками.

Операции сравнения: == (равно; одиночное = — это присваивание!), != (не равно), <, >, <=, >=. Python разрешает цепочки: 0 < x < 10 означает 0 < x and x < 10.

Логические операции: and (И) — истина, только если истинны оба условия; or (ИЛИ) — истина, если истинно хотя бы одно; not (НЕ) — меняет значение на противоположное. Приоритет: not, затем and, затем or. Пример: x % 2 == 0 and x > 10 — x чётное и больше 10. Проверка на делимость: n % k == 0.

Вложенные условия — if внутри if; принадлежность к ветке определяется отступом. Составные условия часто заменяют вложенность: if a > b and a > c: вместо двух вложенных if.

Тернарная запись: m = a if a > b else b — короткое ветвление в одну строку.

Цикл while и обработка цифр числа 8 класс

while условие: — цикл с предусловием: условие проверяется перед каждой итерацией; если оно сразу ложно, тело не выполнится ни разу. Внутри тела что-то обязательно должно менять условие, иначе цикл станет бесконечным.

n = 4728
s = 0
while n > 0:
    s += n % 10   # прибавили последнюю цифру
    n //= 10      # отбросили её
print(s)          # 21

Стандартные задачи на цифры: количество цифр (k += 1 в каждой итерации), сумма цифр (s += n % 10), произведение цифр (p *= n % 10, начальное p = 1), максимальная цифра, число наоборот (r = r * 10 + n % 10), количество чётных цифр (if n % 10 % 2 == 0: k += 1).

Важно: цикл «портит» n (в конце n = 0), поэтому если исходное число нужно потом, сохраните копию: m = n. Для n = 0 цикл while n > 0 не выполнится ни разу — количество цифр получится 0, а не 1.

while удобен, когда число повторений заранее неизвестно: «пока сумма меньше 100», «пока не введут 0», алгоритм Евклида: while a != b: if a > b: a -= b else: b -= a (или быстрее while b: a, b = b, a % b), получаем НОД.

Перевод числа в двоичную систему тоже делается через while: while n > 0: s = str(n % 2) + s; n //= 2.

Цикл for, функция range, break, continue, else 8 класс

for i in range(...) — цикл с параметром: переменная i по очереди принимает значения из диапазона. Формы range: range(n) — 0, 1, ..., n-1 (n чисел); range(a, b) — от a до b-1; range(a, b, k) — от a с шагом k, не доходя до b.

Правая граница никогда не входит: range(1, 5) → 1, 2, 3, 4. Отрицательный шаг — счёт назад: range(10, 0, -3) → 10, 7, 4, 1. Пустые диапазоны: range(5, 1) (шаг +1, а нужно идти вниз) и range(1, 5, -1) — цикл не выполнится ни разу.

for перебирает не только числа, но и элементы строки или списка: for ch in 'abc': — ch = 'a', 'b', 'c'; for x in [3, 8, 1]: — x = 3, 8, 1. После окончания цикла переменная i хранит последнее значение (для range(5) это 4).

break — немедленно прерывает весь цикл. continue — пропускает остаток текущей итерации и переходит к следующей. Обе действуют только на самый внутренний цикл, в котором находятся.

else у цикла выполняется, если цикл закончился «естественно», без break. Классика — проверка на простоту:

n = 29
for d in range(2, n):
    if n % d == 0:
        print('составное')
        break
else:
    print('простое')

Бесконечный цикл с выходом по break: while True: ... if условие: break — удобен, когда проверка нужна в середине тела.

Типовые алгоритмы, вложенные циклы и трассировка 8–9 класс

Счётчик: перед циклом k = 0, внутри if условие: k += 1. Сумматор (накопитель): s = 0, внутри s += x. Произведение: начальное значение p = 1 (не 0, иначе всё время будет 0!). Факториал: f = 1; for i in range(1, n + 1): f *= i.

Поиск максимума: за начальное значение берём первый элемент mx = a[0] (не 0 — вдруг все числа отрицательные), затем if x > mx: mx = x. Для минимума — знак <. Индекс максимума: храним imax, сравниваем a[i] > a[imax]. Строгое > даёт первый максимум, нестрогое >= — последний.

Вложенные циклы: внутренний цикл полностью проходит при каждой итерации внешнего. for i in range(3): for j in range(4): — тело выполнится 3 · 4 = 12 раз. Если внутренний зависит от внешнего (for j in range(i, 4)), считайте по строкам: при i = 0, 1, 2, 3 будет 4 + 3 + 2 + 1 = 10 повторений.

for i in range(1, 4):
    for j in range(1, 4):
        print(i * j, end=' ')
    print()     # перенос строки после каждой строки таблицы

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

Пример трассировки s = 0; for i in range(1, 6, 2): s += i * i: i = 1 → s = 1; i = 3 → s = 10; i = 5 → s = 35. Ответ 35.

Ошибки бывают синтаксические (забыто двоеточие, неверный отступ — программа не запустится), ошибки выполнения (деление на ноль ZeroDivisionError, выход за границы списка IndexError, неверный тип TypeError) и логические (программа работает, но ответ неверный — их ищут трассировкой и тестированием).

Списки (одномерные массивы) и двумерные списки (матрицы) 9 класс

Список — упорядоченный набор элементов: a = [5, 3, 8, 1]. Индексы с нуля: a[0] = 5, a[3] = 1, a[-1] = 1 (последний), a[-2] = 8. len(a) = 4, допустимые индексы 0..3; обращение к a[4] — ошибка IndexError. Элемент можно изменить: a[1] = 10.

Срезы a[start:stop:step] — как range: stop не входит. a[1:3] → элементы с индексами 1 и 2; a[:2] — первые два; a[2:] — с индекса 2 до конца; a[::2] — через один; a[::-1] — список наоборот. Срез создаёт новый список и никогда не вызывает IndexError.

Методы: a.append(x) — добавить в конец; a.insert(i, x) — вставить x на позицию i (остальные сдвигаются вправо); a.pop() — удалить и вернуть последний, a.pop(i) — элемент с индексом i; a.remove(x) — удалить первое вхождение значения x; a.index(x) — индекс первого x; a.count(x) — сколько раз встречается x; a.sort() — сортировка по возрастанию (reverse=True — по убыванию), a.reverse() — разворот. Функции: len(a), sum(a), max(a), min(a), sorted(a) (новый отсортированный список), проверка x in a.

Создание: [0] * 5 → [0, 0, 0, 0, 0]; list(range(1, 6)) → [1, 2, 3, 4, 5]; ввод: a = list(map(int, input().split())). Генератор списка (list comprehension): [i * i for i in range(1, 6)] → [1, 4, 9, 16, 25]; с условием: [x for x in a if x > 0] — только положительные.

Перебор по индексам for i in range(len(a)): нужен, когда важна позиция или нужно менять элементы; перебор по значениям for x in a: — когда нужны только значения. Обмен двух элементов: a[i], a[j] = a[j], a[i].

Двумерный список — список списков: m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]. m[i][j] — элемент в строке i и столбце j: m[1][2] = 6. Число строк len(m), столбцов len(m[0]). Обход — двумя вложенными циклами по i и j.

for i in range(len(m)):
    for j in range(len(m[0])):
        print(m[i][j], end=' ')
    print()

В квадратной матрице n×n: главная диагональ — элементы m[i][i] (i == j), побочная — m[i][n-1-i] (i + j == n - 1); выше главной диагонали i < j, ниже — i > j. Сумма строки i: sum(m[i]); сумма столбца j: sum(m[i][j] for i in range(n)). Правильное создание матрицы нулей: [[0] * m for i in range(n)]; запись [[0] * m] * n создаёт n ссылок на одну и ту же строку, и изменение одного элемента меняет весь столбец.