Подготовка к собеседованию — Квант-исследователь

Короткий ответ: p-value — это вероятность получить статистику как минимум настолько же экстремальную, как наблюдаемая, при условии, что нулевая гипотеза верна: P(данные ≥ наблюдаемых | H₀). Это утверждение о данных при верной H₀, а не о вероятности самой гипотезы.

Подробно:

1. Направление условия — p-value условно по H₀. Чтобы получить P(H₀ | данные), нужны априор и теорема Байеса; из одного p-value эту вероятность не извлечь.
2. Не вероятность нуля — «p = 0.03, значит H₀ верна с вероятностью 3%» — классическая ловушка, на которую интервьюер слушает специально.
3. Не размер эффекта — при огромном n мизерный, экономически бессмысленный эффект даст p < 0.001. Статистическая значимость ≠ практическая важность.

p-value  =  P(T ≥ t_набл | H₀ верна)      ✓
p-value  ≠  P(H₀ верна | данные)          ✗
1 − p    ≠  P(эффект реальный)            ✗

⚠️ Частая ошибка: «1 − p = 97% вероятность, что эффект настоящий». p-value ничего не говорит о вероятности гипотез — только о том, насколько данные удивительны, если H₀ верна.

Короткий ответ: β = Cov(x, y) / Var(x), свободный член α = ȳ − β·x̄. β показывает, на сколько в среднем меняется y при росте x на единицу. Бета из CAPM — ровно этот коэффициент: регрессия доходности актива на доходность рынка.

Подробно:

1. Вывод из нормальных уравнений — минимизируем Σ(yᵢ − α − βxᵢ)², берём производные по α и β и приравниваем к нулю.
2. Через корреляцию — β = ρ(x, y) · σ_y / σ_x: наклон — это корреляция, отмасштабированная отношением волатильностей.
3. CAPM — β_market = Cov(rᵢ, r_m) / Var(r_m): «рыночная бета» акции — буквально коэффициент одномерной OLS доходности актива против рыночной. На интервью это выдаётся мгновенно, без вывода на бумажке.

∂/∂α: Σ(yᵢ − α − βxᵢ) = 0    →  α = ȳ − β·x̄
∂/∂β: Σxᵢ(yᵢ − α − βxᵢ) = 0  →  β = Σ(xᵢ−x̄)(yᵢ−ȳ) / Σ(xᵢ−x̄)²
                                   = Cov(x, y) / Var(x)

⚠️ Частая ошибка: путать направление: β в регрессии y на x — не то же самое, что в регрессии x на y (совпадают только при |ρ| = 1). И «плавать» в формуле — Cov/Var квант обязан писать не задумываясь.

Короткий ответ: Изменяемый объект можно менять на месте (list, dict, set), неизменяемый — нельзя (int, str, tuple). Перепривязка переменной и изменение объекта — разные действия.

items = [1, 2]
alias = items
items.append(3)
assert alias is items and alias == [1, 2, 3]

text = "hello"
original = text
text += " world"
assert original == "hello"  # исходная строка не изменилась

Подробно:

• id() идентифицирует объект и постоянен в течение его жизни. То, что это адрес памяти, — деталь реализации CPython.
• В кортеже нельзя заменить элементы, но вложенный список может изменяться. Неизменяемость не означает автоматически глубокую неизменяемость или потокобезопасность.
• Ключ словаря и элемент множества должны быть хешируемыми: хеш остаётся стабильным, а равные объекты имеют равные хеши. Кортеж со списком нехешируем. Изменяемый экземпляр пользовательского класса может хешироваться по идентичности: хешируемость не синоним неизменяемости.
• Функция получает ссылки на объекты. Мутация аргумента может быть видна вызывающему коду; перепривязка локального параметра не перепривязывает переменную снаружи.

Источники: Хешируемость Python, идентичность объектов.

Короткий ответ: Big O описывает, как растёт время работы или потребление памяти алгоритма при увеличении размера входных данных n, отбрасывая константы и младшие члены. Это верхняя оценка скорости роста.

Подробно:

Big O отвечает на вопрос «что произойдёт, когда n станет очень большим?». Нас не интересует точное число операций, а только характер роста. Поэтому O(2n + 100) упрощается до O(n), а O(3n² + n) — до O(n²).

Основные классы роста (от лучшего к худшему):

# O(1) — константа: не зависит от n
def first(arr):
    return arr[0] if arr else None

# O(log n) — логарифм: каждый шаг делит задачу пополам (бинарный поиск)
def binary_search(arr, target):
    lo, hi = 0, len(arr) - 1
    while lo <= hi:
        mid = (lo + hi) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            lo = mid + 1
        else:
            hi = mid - 1
    return -1

# O(n) — линейная: один проход
def total(arr):
    s = 0
    for x in arr:        # n итераций
        s += x
    return s

# O(n log n) — эффективные сортировки (merge, quick, Timsort)
def sort_it(arr):
    return sorted(arr)

# O(n^2) — квадрат: вложенный цикл
def has_dup_naive(arr):
    for i in range(len(arr)):
        for j in range(i + 1, len(arr)):
            if arr[i] == arr[j]:
                return True
    return False

# O(2^n) — экспонента: наивный Фибоначчи, перебор подмножеств
def fib_naive(n):
    if n < 2:
        return n
    return fib_naive(n - 1) + fib_naive(n - 2)

Ориентир по росту при n = 1 000 000: O(1) — 1 операция, O(log n) — ~20, O(n) — миллион, O(n log n) — ~20 млн, O(n²) — триллион (уже слишком), O(2^n) — нереально даже при n = 50.

⚠️ Ловушка: Big O — это про асимптотику (поведение при больших n), а не про реальное время. O(n) алгоритм может быть медленнее O(n²) на маленьких данных из-за больших констант. Также путают: Big O (верхняя граница, Ω — нижняя, Θ — точная), в собесах под «O» обычно подразумевают Θ.

Короткий ответ: Метод Монте-Карло «дартс»: бросаем N случайных точек в единичный квадрат и считаем долю попавших в четверть круга (x² + y² ≤ 1). Эта доля сходится к π/4, значит π ≈ 4 · (доля попаданий).

Подробно:

1. Геометрия — площадь четверти круга радиуса 1 равна π/4, площадь квадрата равна 1; вероятность попадания — отношение площадей.
2. Сходимость — по ЦПТ ошибка убывает как 1/√N: каждая дополнительная значащая цифра стоит в ~100 раз больше выборок.
3. Векторизация — генерируем все точки разом, без питоновского цикла по одной точке.

import numpy as np

rng = np.random.default_rng(42)
n = 10_000_000
x, y = rng.random(n), rng.random(n)
pi_hat = 4 * np.mean(x**2 + y**2 <= 1)
# ошибка ~ 1/sqrt(n): при n = 10^7 верны примерно 3–4 знака

⚠️ Частая ошибка: ждать от Монте-Карло быстрой точности: чтобы получить 6 знаков вместо 3, нужно в ~10⁶ раз больше точек. Для самой константы π это худший из методов — но вопрос проверяет, понимаете ли вы скорость сходимости 1/√N, общую для всех МК-оценок.