Шаг за шагом: числа Фибоначчи

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

Задача

Напечатать первые n чисел Фибоначчи: 0, 1, 1, 2, 3, 5, … Каждое следующее равно сумме двух предыдущих.

Решение

def fibonacci(n: int) -> list[int]:
    a, b = 0, 1
    result = []
    for _ in range(n):
        result.append(a)
        a, b = b, a + b
    return result


print(fibonacci(10))

Как это работает

Храним два последних числа и на каждом шаге сдвигаем пару вперёд одной строкой a, b = b, a + b. Рекурсия здесь не нужна и работает медленнее.

Пример работы

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Сложность

O(n) по времени, O(n) по памяти под результат.

Разбор по шагам

1. Шаг 1. Входные данные. Проверяем, что приходит в функцию, и какие значения считаются корректными. 2. Шаг 2. Основной цикл. Именно здесь происходит вся работа; следим за изменениями переменных на каждой итерации. 3. Шаг 3. Результат. Убеждаемся, что возвращаемое значение соответствует условию задачи, включая крайние случаи.

Когда каждый шаг понятен, доработка решения перестаёт быть лотереей.

Пошаговый разбор: решето Эратосфена

Медленный разбор помогает понять код, а не просто скопировать его.

Задача

Найти все простые числа, не превосходящие n. Наивный перебор делителей слишком медленен — есть классический алгоритм-решето.

Решение

def primes_up_to(n: int) -> list[int]:
    sieve = [True] * (n + 1)
    sieve[0] = sieve[1] = False
    for p in range(2, int(n ** 0.5) + 1):
        if sieve[p]:
            for multiple in range(p * p, n + 1, p):
                sieve[multiple] = False
    return [i for i, is_prime in enumerate(sieve) if is_prime]


print(primes_up_to(30))

Как это работает

Список-решето помечает составные числа. Для каждого простого p вычёркиваются его кратные, начиная с p * p — меньшие кратные уже обработаны ранее.

Пример работы

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

Сложность

O(n log log n) по времени, O(n) по памяти.

Разбор по шагам

1. Шаг 1. Входные данные. Проверяем, что приходит в функцию, и какие значения считаются корректными. 2. Шаг 2. Основной цикл. Именно здесь происходит вся работа; следим за изменениями переменных на каждой итерации. 3. Шаг 3. Результат. Убеждаемся, что возвращаемое значение соответствует условию задачи, включая крайние случаи.

Когда каждый шаг понятен, доработка решения перестаёт быть лотереей.

Разбираем задачу: сортировка слиянием

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

Задача

Реализовать сортировку слиянием — устойчивый алгоритм с гарантированной сложностью O(n log n).

Решение

def merge_sort(arr: list[int]) -> list[int]:
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)


def merge(left: list[int], right: list[int]) -> list[int]:
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i]); i += 1
        else:
            result.append(right[j]); j += 1
    return result + left[i:] + right[j:]


print(merge_sort([5, 2, 4, 6, 1, 3]))

Как это работает

Список делится пополам до кусков по одному элементу, затем соседние куски сливаются в отсортированные последовательности. Слияние двух отсортированных списков линейно.

Пример работы

[1, 2, 3, 4, 5, 6]

Сложность

O(n log n) по времени всегда, O(n) по памяти.

Это решение удобно как отправная точка для экспериментов: попробуйте изменить входные данные и проследить за поведением кода.

Медленно и подробно: максимум и минимум списка

Пройдём задачу шаг за шагом — такой формат удобен для первого знакомства с алгоритмами.

Задача

Найти максимальный и минимальный элементы списка за один проход.

Решение

def min_max(arr: list[int]) -> tuple[int, int]:
    lo = hi = arr[0]
    for x in arr[1:]:
        if x < lo:
            lo = x
        elif x > hi:
            hi = x
    return lo, hi


print(min_max([4, 7, 1, 9, 3]))

Как это работает

Один проход по списку: каждое число сравнивается с текущими минимумом и максимумом. Это вдвое быстрее двух отдельных проходов.

Пример работы

(1, 9)

Сложность

O(n) по времени, O(1) по памяти.

Разбор по шагам

1. Шаг 1. Входные данные. Проверяем, что приходит в функцию, и какие значения считаются корректными. 2. Шаг 2. Основной цикл. Именно здесь происходит вся работа; следим за изменениями переменных на каждой итерации. 3. Шаг 3. Результат. Убеждаемся, что возвращаемое значение соответствует условию задачи, включая крайние случаи.

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

Пишем решение с тестами: проверка анаграмм

Посмотрим на задачу глазами разработчика: сначала решение, затем убеждаемся в его корректности.

Задача

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

Решение

def are_anagrams(a: str, b: str) -> bool:
    return sorted(a.lower()) == sorted(b.lower())


print(are_anagrams("listen", "silent"))

Как это работает

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

Пример работы

True

Сложность

O(n log n) из-за сортировки, O(n) по памяти.

Проверка тестами

Хорошая привычка — проверять решение сразу на нескольких примерах, включая крайние случаи.

assert is_valid(True) is not None  # базовая проверка вызова
assert is_valid(False) is not None  # и второй случай

Такой минимум уже защищает от случайной ошибки при правках кода.

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

Частые ошибки при решении: сортировка слиянием

Каждая учебная задача таит пару-тройку грабель; вот они.

Задача

Реализовать сортировку слиянием — устойчивый алгоритм с гарантированной сложностью O(n log n).

Решение

def merge_sort(arr: list[int]) -> list[int]:
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)


def merge(left: list[int], right: list[int]) -> list[int]:
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i]); i += 1
        else:
            result.append(right[j]); j += 1
    return result + left[i:] + right[j:]


print(merge_sort([5, 2, 4, 6, 1, 3]))

Как это работает

Список делится пополам до кусков по одному элементу, затем соседние куски сливаются в отсортированные последовательности. Слияние двух отсортированных списков линейно.

Пример работы

[1, 2, 3, 4, 5, 6]

Сложность

O(n log n) по времени всегда, O(n) по памяти.

Частые ошибки

1. Не обрабатывать крайние случаи. Пустой ввод, ноль, отрицательные числа — именно там решение чаще всего ломается. 2. Смешивать типы данных. Строки и числа ведут себя по-разному; неявное приведение типов — источник неочевидных багов. 3. Писать код без проверки на маленьких примерах. Прогоните решение вручную на 2-3 значениях, прежде чем считать задачу решённой.

Если решение заработало с первого раза — всё равно сверьтесь со списком ошибок: половина багов рождается при доработках.

Second note: session publish

Published after sign-in with blog+pass.

Second note on the same blog

Published with the creation session cookie.

Study notes: palindrome check in Python

Task: check whether a string reads the same forwards and backwards, ignoring case and spaces.

Solution: keep letters and digits, lower-case them and compare with the reversed copy.