Workshop Hub Notes

Два способа решения: бинарный поиск

2026-11-06T13:36:00+02:00

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

Задача

Дан отсортированный список чисел arr и число target. Найти его индекс или вернуть -1, если элемента нет.

Решение


def binary_search(arr: list[int], target: int) -> int:
    lo, hi = 0, len(arr) - 1
    while lo <= hi:
        mid = (lo + hi) // 2
        if arr[mid] == target:
            return mid
        if arr[mid] < target:
            lo = mid + 1
        else:
            hi = mid - 1
    return -1


print(binary_search([1, 3, 5, 7, 9, 11], 7))

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

На каждом шаге диапазон поиска сокращается вдвое: если середина меньше цели — ищем справа, иначе слева. Отсюда и логарифмическая скорость.

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

Сложность

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

Альтернативный подход

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

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

---

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

2026-11-06T09:35:00+02:00

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

Задача

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

Решение


def unique(arr: list) -> list:
    seen = set()
    result = []
    for x in arr:
        if x not in seen:
            seen.add(x)
            result.append(x)
    return result


print(unique([1, 2, 2, 3, 1, 4]))

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

Множество seen отвечает за быструю проверку «встречался ли элемент», список result сохраняет порядок. Простое приведение к set() порядок бы не сохранило.

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


[1, 2, 3, 4]

Сложность

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

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

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


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

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

Тесты вида assert удобны для учебных задач: они короткие, наглядные и не требуют фреймворков.

---

Рассматриваем задачу: наибольший общий делитель

2026-11-04T01:15:00+02:00

В этом материале мы спокойно и по шагам разберём учебную задачу на программирование.

Задача

Найти НОД двух натуральных чисел a и b — классическая задача школьной математики и один из древнейших алгоритмов.

Решение


def gcd(a: int, b: int) -> int:
    while b:
        a, b = b, a % b
    return a


print(gcd(48, 18))

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

Алгоритм Евклида: НОД(a, b) = НОД(b, a mod b). Остаток всегда меньше делителя, поэтому числа быстро уменьшаются: (48, 18) → (18, 12) → (12, 6) → (6, 0).

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

Сложность

O(log min(a, b)) по времени, O(1) по памяти.

Такой пример хорошо закрепляется практикой — перепишите решение руками и прогоните на своих тестах.

---

Пишем решение с тестами: бинарный поиск

2026-11-03T13:20:00+02:00

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

Задача

Дан отсортированный список чисел arr и число target. Найти его индекс или вернуть -1, если элемента нет.

Решение


def binary_search(arr: list[int], target: int) -> int:
    lo, hi = 0, len(arr) - 1
    while lo <= hi:
        mid = (lo + hi) // 2
        if arr[mid] == target:
            return mid
        if arr[mid] < target:
            lo = mid + 1
        else:
            hi = mid - 1
    return -1


print(binary_search([1, 3, 5, 7, 9, 11], 7))

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

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

Сложность

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

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

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


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

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

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

Несколько вариантов решения: проверка анаграмм

2026-11-03T13:19:00+02:00

У большинства учебных задач есть минимум два честных решения — сравним их.

Задача

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

Решение


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) по памяти.

Альтернативный подход

Оба подхода рабочие; важно понимать цену каждого, а не копировать первый попавшийся.

Частые ошибки при решении: сумма цифр числа

2026-11-03T01:11:00+02:00

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

Задача

Найти сумму цифр натурального числа n, например для 1234 ответ 1 + 2 + 3 + 4 = 10.

Решение


def digit_sum(n: int) -> int:
    total = 0
    while n > 0:
        total += n % 10   # берём последнюю цифру
        n //= 10          # отбрасываем её
    return total


print(digit_sum(1234))

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

Операция n % 10 выделяет последнюю цифру, а целочисленное деление n //= 10 убирает её. Цикл продолжается, пока число не станет нулём.

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

Сложность

O(log n) по времени — по числу цифр, O(1) по памяти.

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

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

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

Пишем решение с тестами: решето Эратосфена

2026-11-02T13:18:00+02:00

Разберём решение и сразу накроем его тестами — это хороший стиль работы с кодом.

Задача

Найти все простые числа, не превосходящие 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) по памяти.

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

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


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

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

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

Ловушки новичков при решении: подсчёт частот слов

2026-11-02T13:17:00+02:00

Разберём решение и подводные камни — их обычно не видно в готовом коде из учебника.

Задача

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

Решение


from collections import Counter


def word_count(text: str) -> list[tuple[str, int]]:
    words = text.lower().split()
    return Counter(words).most_common()


print(word_count("a b a c b a"))

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

Текст разбивается на слова, Counter подсчитывает вхождения за линейное время, а most_common() сразу возвращает отсортированный список пар.

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


[('a', 3), ('b', 2), ('c', 1)]

Сложность

O(n) по времени по числу слов, O(k) по памяти по числу уникальных.

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

Медленно и подробно: быстрая сортировка

2026-11-02T01:10:00+02:00

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

Задача

Реализовать быструю сортировку — один из самых известных алгоритмов «разделяй и властвуй».

Решение


def quicksort(arr: list[int]) -> list[int]:
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)


print(quicksort([3, 6, 8, 10, 1, 2, 1]))

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

Выбирается опорный элемент, массив делится на три части (меньше, равно, больше), затем части сортируются рекурсивно и склеиваются.

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


[1, 1, 2, 3, 6, 8, 10]

Сложность

O(n log n) в среднем, O(n²) в худшем случае.

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

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

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

Testing publish state one

2026-11-01T14:05:00+02:00

Testing publish state one

Body text.