Quant Researcher interview prep

Short answer: A p-value is the probability of observing a test statistic at least as extreme as the one you got, assuming the null hypothesis is true: P(data ≥ observed | H₀). It is a statement about the data under H₀ — not about the probability of the hypothesis itself.

In depth:

1. Direction of the conditioning — the p-value conditions on H₀. Getting P(H₀ | data) requires a prior and Bayes' theorem; you cannot extract it from a p-value alone.
2. Not the probability of the null — "p = 0.03 means H₀ is true with probability 3%" is the classic trap interviewers specifically listen for.
3. Not an effect size — with huge n, a tiny, economically meaningless effect yields p < 0.001. Statistical significance ≠ practical importance.

p-value  =  P(T ≥ t_obs | H₀ true)        ✓
p-value  ≠  P(H₀ true | data)             ✗
1 − p    ≠  P(the effect is real)         ✗

⚠️ Common mistake: "1 − p = 97% probability the effect is real." A p-value says nothing about the probability of hypotheses — only how surprising the data are if H₀ holds.

Short answer: β = Cov(x, y) / Var(x), intercept α = ȳ − β·x̄. β is how much y changes on average when x rises by one unit. CAPM beta is exactly this coefficient: a regression of asset returns on market returns.

In depth:

1. Derivation from the normal equations — minimize Σ(yᵢ − α − βxᵢ)², take derivatives with respect to α and β, set them to zero.
2. Via correlation — β = ρ(x, y) · σ_y / σ_x: the slope is the correlation scaled by the ratio of volatilities.
3. CAPM — β_market = Cov(rᵢ, r_m) / Var(r_m): a stock's "market beta" is literally the one-regressor OLS coefficient of asset returns against market returns. In an interview this must come out instantly, no scratch paper.

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

⚠️ Common mistake: mixing up direction: the β from regressing y on x is not the β from regressing x on y (they coincide only when |ρ| = 1). And fumbling the formula — a QR is expected to write Cov/Var without thinking.

Short answer: Mutable objects can change in place (list, dict, set); immutable objects cannot (int, str, tuple). Rebinding a variable is different from mutating its object.

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"  # the original string did not change

In depth:

• id() identifies an object and stays constant during its lifetime. Treating it as a memory address is a CPython implementation detail.
• A tuple cannot replace its elements, but a list stored inside it can still change. Immutability is not automatically deep immutability or thread safety.
• Dictionary keys and set elements must be hashable: their hash stays stable, and equal objects have equal hashes. A tuple containing a list is unhashable. A user-defined mutable instance can be hashable by identity, so hashability is not synonymous with immutability.
• Functions receive references to objects. Mutating an argument can affect the caller; rebinding a local parameter does not rebind the caller's variable.

Sources: Python hashability, object identity.

Short answer: Big O describes how an algorithm's running time or memory usage grows as the input size n increases, dropping constants and lower-order terms. It's an upper bound on the growth rate.

In detail:

Big O answers the question "what happens when n becomes very large?". We're not interested in the exact number of operations, only the nature of the growth. That's why O(2n + 100) simplifies to O(n), and O(3n² + n) — to O(n²).

The main growth classes (from best to worst):

# O(1) — constant: doesn't depend on n
def first(arr):
    return arr[0] if arr else None

# O(log n) — logarithmic: each step halves the problem (binary search)
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) — linear: a single pass
def total(arr):
    s = 0
    for x in arr:        # n iterations
        s += x
    return s

# O(n log n) — efficient sorts (merge, quick, Timsort)
def sort_it(arr):
    return sorted(arr)

# O(n^2) — quadratic: a nested loop
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) — exponential: naive Fibonacci, enumerating subsets
def fib_naive(n):
    if n < 2:
        return n
    return fib_naive(n - 1) + fib_naive(n - 2)

A rough guide to growth at n = 1,000,000: O(1) — 1 operation, O(log n) — ~20, O(n) — a million, O(n log n) — ~20 million, O(n²) — a trillion (already too much), O(2^n) — infeasible even at n = 50.

⚠️ Gotcha: Big O is about asymptotics (behavior at large n), not about actual time. An O(n) algorithm can be slower than an O(n²) one on small data because of large constants. People also confuse: Big O (upper bound), Ω (lower bound), Θ (tight bound); in interviews "O" usually means Θ.

Short answer: Monte Carlo "darts": throw N random points into the unit square and take the fraction landing inside the quarter circle (x² + y² ≤ 1). That fraction converges to π/4, so π ≈ 4 · (hit fraction).

In depth:

1. Geometry — the quarter circle of radius 1 has area π/4, the square has area 1; the hit probability is the ratio of areas.
2. Convergence — by the CLT the error decays as 1/√N: each extra significant digit costs ~100× more samples.
3. Vectorization — generate all points at once, no Python loop over individual points.

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)
# error ~ 1/sqrt(n): at n = 10^7 roughly 3–4 digits are correct

⚠️ Common mistake: expecting Monte Carlo to reach precision quickly: going from 3 to 6 correct digits takes ~10⁶× more points. For the constant π itself this is the worst possible method — but the question tests whether you understand the 1/√N convergence rate shared by every MC estimate.