Quantitative Researcher Interview Prep

From hundreds of mock interviews, the single biggest surprise is how many candidates with perfect probability scores get cut for lacking finance intuition. Quant researcher comp ranges from $150K at the junior floor to $5M at the principal ceiling, yet the interview loop cares less about your math ceiling than whether you can reason about why a signal decays after transaction costs. That gap between "smart" and "profitable" is exactly what firms screen for.

What Quantitative Researchers Actually Do

You'll find this role at multi-strategy hedge funds (Citadel, Two Sigma, DE Shaw, Millennium), prop trading firms (Jane Street, Optiver, SIG), and occasionally on banks' electronic trading desks. The work spans everything from prototyping cross-sectional equity factor models in Python to refining C++ execution algorithms that reduce market impact by a few basis points. Success after year one means a signal you built made it into the live portfolio and generated attributable PnL, not just a well-received research memo.

A Typical Week

Only about 15% of the week is meetings, but each one is high-density: think PnL attribution reviews where a strategy head grills your out-of-sample methodology, not status standups. What candidates consistently underestimate is the 10% writing allocation. Internal research memos circulate to the CIO's office, and sloppy prose erodes your credibility with portfolio managers just as fast as a flawed backtest.

Skills & What's Expected

Machine learning scores "high" in the skill profile for good reason: you'll use scikit-learn for feature selection pipelines and, at some firms, TensorFlow for nonlinear signal models. But the ML that matters here is interpretable and low-latency (penalized regression, gradient-boosted trees, Kalman filters), not billion-parameter architectures. The truly underrated skill is writing production-grade C++ for an optimizer module or transaction cost model. Plenty of PhD candidates can derive a shrinkage estimator on a whiteboard yet freeze when asked to refactor that math into tested, reviewable code. Business acumen also scores surprisingly high because you're expected to reason about market microstructure, capacity constraints, and Sharpe degradation from trading costs without someone holding your hand.

Levels & Career Growth

Most hires land at entry or mid level, even with a PhD, because firms want to see you produce PnL before granting autonomy. The jump from mid to senior is where careers stall: it demands demonstrating independent alpha generation, not just executing on someone else's research agenda. At staff and above, the path splits between IC leadership (shaping firm-wide research methodology across multiple desks) and portfolio management (running your own book with direct capital allocation). Either way, comp becomes overwhelmingly bonus-driven, and a bad year on your strategy can cut total pay by half or more.

Quantitative Researcher Compensation

The bonus is the comp. Bases at quant firms cluster in a narrow band regardless of seniority, so your total package lives or dies on the variable piece. At pod shops like Citadel or Millennium, that variable piece is a cut of your desk's PnL. A strong year might push total comp to 3x base, while a flat year could leave you near base with a bonus that barely covers taxes. Multi-strat firms like Two Sigma and DE Shaw tend toward more structured bonus pools, which smooths the volatility but caps the upside. Bank quant desks (Goldman, JPMorgan) sit at the lower end of each band, though they offer more stability since bonuses there are tied to firm-wide revenue pools rather than a single strategy's P&L.

Deferred compensation is the gotcha most candidates miss. At senior levels, 20-40% of your bonus may vest over two to three years, and unvested portions are typically forfeited if you leave (though some firms allow partial vesting or negotiate exceptions during lateral moves). For negotiation, the lever that actually moves is the first-year guaranteed minimum, not base salary. Competing offers from big tech companies force quant firms to compete on guaranteed money rather than projections about future PnL splits. Push hard on guarantee length: locking in a two-year floor instead of one year can mean six figures of downside protection while your strategy ramps. And when a recruiter quotes an "expected" bonus number, pin them down on what a bad year looks like, because that figure is often a rosy target, not a floor.

Quantitative Researcher Interview Process

Expect roughly 6 weeks from your first recruiter call to a final offer, based on data across 14 firms. Larger multi-strat funds tend to add buffer for PM interviews and committee sign-offs, while smaller systematic shops sometimes move faster when they have an urgent seat to fill. The process structure above is consistent across firm types, but the format shifts: some firms run rounds 2 through 5 as back-to-back on-site sessions, others spread them across weeks of video calls.

The most common elimination point, from what candidates report, is the statistics and probability round. It's not that people get answers wrong; it's that they can't articulate a structured approach under time pressure, which interviewers read as weak fundamentals rather than nerves. One pattern worth knowing: strong case study performance can rescue a wobbly earlier round, because that's where you demonstrate the end-to-end thinking (hypothesis, feature engineering, backtest, cost-adjusted evaluation) that separates researchers from puzzle-solvers.

Quantitative Researcher Interview Questions

Probability & Mathematical Reasoning

Your execution model assumes each of $n$ child orders fills independently with probability $p$, but the desk thinks there is a common liquidity shock so fills are positively dependent; name a realistic one-factor model for this and explain how it changes $\mathrm{Var}(K)$ for the fill count $K$. Be explicit about whether variance goes up or down versus $\mathrm{Binomial}(n,p)$.

AQRMediumDependence and Mixture Models

Sample Answer

You could model dependence with a Beta-Binomial mixture (random $p$ driven by a latent liquidity factor) or with a Gaussian copula on Bernoulli latents. The Beta-Binomial wins here because it gives an analytic variance decomposition: $\mathrm{Var}(K)=\mathbb{E}[\mathrm{Var}(K\mid p)]+\mathrm{Var}(\mathbb{E}[K\mid p])=n\mathbb{E}[p(1-p)]+n^2\mathrm{Var}(p)$. Compared to $\mathrm{Binomial}(n,p)$, the extra $n^2\mathrm{Var}(p)$ term makes variance strictly larger when $\mathrm{Var}(p)>0$, that is the overdispersion you see under common shocks.

A daily PnL stream has i.i.d. returns with tail $\mathbb{P}(R>x)\sim Cx^{-\alpha}$ for large $x$ with $\alpha\in(1,2)$; how does the $q$-quantile of the $n$-day sum $S_n=\sum_{t=1}^n R_t$ scale with $n$ for fixed high $q$ close to 1? State the scaling and justify it without invoking a full theorem statement.

AQRHardHeavy Tails and Stable Scaling

Sample Answer

Unlock the full solution

View detailed answers and practice in our question bank

View Solution

Practice more Probability & Mathematical Reasoning questions

Statistics

Most candidates underestimate how much precision matters when you talk about estimators, bias/variance, uncertainty, and asymptotics. You’ll need to translate messy market-style data situations into statistically sound procedures and sanity checks.

What is a confidence interval and how do you interpret one?

EasyFundamentals

Sample Answer

A 95% confidence interval is a range of values that, if you repeated the experiment many times, would contain the true population parameter 95% of the time. For example, if a survey gives a mean satisfaction score of 7.2 with a 95% CI of [6.8, 7.6], it means you're reasonably confident the true mean lies between 6.8 and 7.6. A common mistake is saying "there's a 95% probability the true value is in this interval" — the true value is fixed, it's the interval that varies across samples. Wider intervals indicate more uncertainty (small sample, high variance); narrower intervals indicate more precision.

You run a daily cross-sectional regression of next-day returns on a single standardized value signal across 2,000 US equities, then average the daily slope to estimate the signal premium; what is the right way to compute a standard error and $t$-stat when slopes are serially correlated? Name a concrete adjustment and what drives the lag choice.

AQRMediumInference under dependence

Sample Answer

Most candidates default to the naive standard error of the time-series mean of daily slopes assuming IID, but that fails here because factor premia are autocorrelated and volatility clusters. You should use a HAC estimator (Newey-West) on the time series of daily slopes, or equivalently block bootstrap those slopes, so the variance accounts for serial dependence. The lag is driven by the correlation horizon in the slope series (often tied to signal decay, rebalancing frequency, and microstructure effects), and you sanity check it via the slope ACF and stability of the $t$-stat across reasonable lag choices.

Your return-prediction regression uses daily stock returns and 20 characteristics, and you see clear heteroskedasticity across market cap; how does this change coefficient inference, and when would you switch from OLS standard errors to robust or GLS-style approaches? Be explicit about what remains unbiased and what breaks.

AQRHardRegression diagnostics and robust inference

Sample Answer

Unlock the full solution

View detailed answers and practice in our question bank

View Solution

Practice more Statistics questions

Machine Learning & Modeling

Your ability to choose and critique models is tested more than your ability to name them. You’ll need to diagnose overfitting, leakage, non-stationarity, and evaluation pitfalls common in alpha research, and justify modeling tradeoffs with rigor.

What is the bias-variance tradeoff?

EasyFundamentals

Sample Answer

Bias is error from oversimplifying the model (underfitting) — a linear model trying to capture a nonlinear relationship. Variance is error from the model being too sensitive to training data (overfitting) — a deep decision tree that memorizes noise. The tradeoff: as you increase model complexity, bias decreases but variance increases. The goal is to find the sweet spot where total error (bias squared + variance + irreducible noise) is minimized. Regularization (L1, L2, dropout), cross-validation, and ensemble methods (bagging reduces variance, boosting reduces bias) are practical tools for managing this tradeoff.

You are building a monthly cross-sectional equity return model using fundamentals, analyst revisions, and price-based signals, and you must choose between (a) L1-regularized linear regression on standardized features and (b) gradient-boosted trees. Which do you pick for a first production-quality signal at top tech companies, and how do you validate it to avoid lookahead and overfitting?

AQRMediumModel Selection and Validation

Sample Answer

You could do L1-regularized linear regression or gradient-boosted trees. L1 wins here because it is easier to audit for leakage, more stable under non-stationarity, and gives you a clean mapping from predictors to exposures that risk and portfolio construction can actually use. Validate with a strict time-series split and an embargo around the label horizon, then evaluate by out-of-sample IC, turnover, and net-of-cost Sharpe instead of generic $R^2$.

You train a model to predict next-month returns using daily features aggregated to month-end, and backtest performance collapses when you switch from random CV to time-based CV. Walk through, step by step, the most likely leakage paths and the fixes, including how you would implement purged and embargoed validation for a label with horizon $h$.

AQRHardLeakage and Non-Stationary Validation

Sample Answer

Unlock the full solution

View detailed answers and practice in our question bank

View Solution

Practice more Machine Learning & Modeling questions

Mathematics

You fit a linear signal $\hat y = X\beta$ for intraday return prediction with ridge: $$\min_\beta \; \lVert y - X\beta \rVert_2^2 + \lambda \lVert \beta \rVert_2^2.$$ Write the closed form $\hat\beta$ and explain what happens as $\lambda \to \infty$ to the fitted exposures in the eigenbasis of $X^\top X$.

CitadelMediumRegularized Least Squares and Spectral View

Sample Answer

This question is checking whether you can move between algebra and geometry, then reason about shrinkage where collinearity is severe. The solution is $$\hat\beta = (X^\top X + \lambda I)^{-1} X^\top y,$$ assuming $\lambda > 0$ so the matrix is invertible. Diagonalize $X^\top X = Q\Lambda Q^\top$, then $$\hat\beta = Q(\Lambda + \lambda I)^{-1}Q^\top X^\top y,$$ so each eigen-direction is scaled by $\frac{1}{\lambda_i + \lambda}$. As $\lambda \to \infty$, all directions shrink to $0$, and the model collapses toward zero exposures, which is exactly the point when you do not trust the cross-sectional conditioning.

You need to compute a risk parity portfolio for a futures book by minimizing $$f(w)=\frac{1}{2} w^\top \Sigma w - \sum_{i=1}^n \log w_i$$ with constraint $w_i>0$ (barrier encourages diversification). Derive $\nabla f(w)$ and $\nabla^2 f(w)$, then state a sufficient condition for $f$ to be strictly convex.

CitadelHardConvexity, Gradients, Hessians

Sample Answer

Unlock the full solution

View detailed answers and practice in our question bank

View Solution

Practice more Mathematics questions

Coding & Algorithms

In this section you are proving you can turn a tight mathematical idea into correct, fast Python. Expect problems where edge cases matter, you need clean reasoning about complexity, and your code has to be readable under pressure.

In a backtest you have daily simple returns $r_t$ and you want the maximum sum over any contiguous subarray of $r_t$ after applying a per-day risk penalty $λ r_t^2$ (objective is maximize $\sum (r_t - \lambda r_t^2)$). Return the max objective value and the start and end indices in $O(n)$ time.

CitadelMediumDynamic Programming, Maximum Subarray

Sample Answer

You could do brute force over all $O(n^2)$ subarrays or use Kadane style dynamic programming on the transformed values $x_t = r_t - \lambda r_t^2$. The brute force approach is dead on arrival for realistic backtests, since it is quadratic and easy to TLE. Kadane wins here because it maintains the best subarray ending at each index in $O(1)$, giving $O(n)$ time and $O(1)$ extra space while still letting you recover the argmax interval.

from typing import List, Tuple


def max_risk_penalized_subarray(returns: List[float], lam: float) -> Tuple[float, int, int]:
    """Maximize sum_{t=i..j} (r_t - lam * r_t^2) over contiguous subarrays.

    Args:
        returns: Daily simple returns r_t.
        lam: Risk penalty coefficient (can be 0).

    Returns:
        (best_value, start_idx, end_idx), where indices are inclusive.
        For empty input, returns (0.0, -1, -1).
    """
    n = len(returns)
    if n == 0:
        return 0.0, -1, -1

    # Transform each day into a score.
    x = [r - lam * (r * r) for r in returns]

    best_sum = x[0]
    best_l = best_r = 0

    curr_sum = x[0]
    curr_l = 0

    for i in range(1, n):
        # Either extend or restart at i.
        if curr_sum + x[i] >= x[i]:
            curr_sum += x[i]
        else:
            curr_sum = x[i]
            curr_l = i

        # Update global best.
        if curr_sum > best_sum:
            best_sum = curr_sum
            best_l = curr_l
            best_r = i

    return float(best_sum), int(best_l), int(best_r)


if __name__ == "__main__":
    r = [0.01, -0.02, 0.015, 0.005, -0.001]
    print(max_risk_penalized_subarray(r, lam=10.0))

You are building an-style daily rebalancer: given $N$ assets with expected returns $\mu_i$, risk model covariance $\Sigma$, per-asset transaction cost rates $c_i$, and current weights $w^{(0)}$, compute the new weights $w$ that maximize $\mu^\top w - \lambda w^\top \Sigma w - \sum_i c_i |w_i - w_i^{(0)}|$ subject to $\sum_i w_i = 1$ and box constraints $l_i \le w_i \le u_i$. Implement a solver using coordinate descent with soft-thresholding and projection, and return $w$ plus the objective value.

AQRHardConvex Optimization via Coordinate Descent

Sample Answer

Unlock the full solution

View detailed answers and practice in our question bank

View Solution

Practice more Coding & Algorithms questions

Business & Finance

What is ROI and how would you calculate it for a data science project?

EasyFundamentals

Sample Answer

ROI (Return on Investment) = (Net Benefit - Cost) / Cost x 100%. For a data science project, costs include engineering time, compute, data acquisition, and maintenance. Benefits might be revenue uplift from a recommendation model, cost savings from fraud detection, or efficiency gains from automation. Example: a churn prediction model costs $200K to build and maintain, and saves $1.2M/year in retained revenue, so ROI = ($1.2M - $200K) / $200K = 500%. The hard part is isolating the model's contribution from other factors — use a holdout group or A/B test to measure incremental impact rather than attributing all improvement to the model.

You have a daily cross-sectional value signal for US equities and you suspect it is just a dressed-up low-beta or quality tilt; what exact regression or portfolio tests do you run to separate alpha from risk premia, and what would convince you the signal is still real after controls?

AQRMediumFactor Attribution and Risk Premia

Sample Answer

Reason through it: Start by defining the unit of analysis, usually daily or monthly cross-sectional returns, and decide whether you are testing forecasting power (IC) or monetizable returns (long-short). Then run cross-sectional regressions of next-period returns on your signal and a set of known exposures, for example market beta, size, value, momentum, quality, industry dummies, using standardized exposures so coefficients are comparable. Next, build a beta-neutral and factor-neutral version via residualization, trade it with the same portfolio construction rules, and check whether net performance survives after realistic costs and turnover. You get convinced when the signal keeps a stable, positive coefficient and a robust IC, and the residualized portfolio keeps Sharpe and hit rate across regimes, not just in-sample.

You are asked to implement a daily long-short equity factor with 15 bps one-way costs and a 10% daily ADV participation cap; how do you decide whether to trade at the close or use a one-day delay, and how do you estimate capacity in dollars for the strategy?

AQRHardTransaction Costs and Capacity

Sample Answer

Start with what the interviewer is really testing: This question is checking whether you can translate backtest PnL into implementable PnL under costs, market impact, and liquidity constraints. You compare close-to-close execution versus a delay by mapping signal formation time to realistic fills and by explicitly modeling slippage, spread, and impact, then re-running the backtest net of those. Capacity comes from the binding constraint, typically participation, so you compute per-name max tradable shares per day as $0.10 \times \text{ADV}$ and convert to dollars, then aggregate across the portfolio subject to your turnover and rebalance schedule. If the required daily traded notional from turnover exceeds what participation allows, the strategy is capacity-limited and the paper Sharpe is fake.

Practice more Business & Finance questions

Math

Your ability to reason about objective functions, constraints, and stability is a direct proxy for whether you can build tradable models. Interviewers look for linear algebra fluency, convexity intuition, and the ability to sanity-check derivations.

You have 3 years of daily returns for 2,000 equities and 50 candidate alpha signals computed at EOD, and you want to ship a market-neutral long short portfolio with 10 bps expected daily turnover cost. Design a research plan to estimate out-of-sample Sharpe and decide whether any signal is real after multiple testing, and specify what you would plot as sanity checks.

DE ShawMediumAlpha Research, Multiple Testing, Time Series CV

Sample Answer

This question is checking whether you can separate signal from noise under dependence, costs, and selection bias. You need a time-series aware validation scheme (for example, rolling or purged walk-forward), explicit transaction cost modeling in the objective, and a multiple testing correction (for example, BH-FDR on per-signal IC t-stats with Newey West standard errors). Sanity plots should include cumulative PnL with drawdowns, IC over time, turnover and capacity curves, and performance versus market regime buckets to catch instability.

A high frequency market making model shows a strong edge in backtest, but live PnL collapses after launch, and the only change is that quotes are now subject to queue priority and occasional partial fills. Propose a minimal mathematical model for fill probability as a function of spread, queue position, and latency, then explain how you would re-estimate expected PnL and risk with that model.

DE ShawHardMarket Microstructure, Fill Modeling, Execution Risk

Sample Answer

Unlock the full solution

View detailed answers and practice in our question bank

View Solution

Practice more Math questions

ML Coding & Implementation

You are prototyping a cross-sectional signal for a market-neutral equities book: each minute, rank stocks by a feature $x_{i,t}$ and trade the next minute return $r_{i,t+1}$. Write code that computes Spearman rank IC per minute and the overall mean IC, while correctly handling ties and missing data.

CitadelMediumBacktest Metrics and Validation

Sample Answer

The standard move is to compute Spearman IC as the Pearson correlation of ranks between $x_{i,t}$ and $r_{i,t+1}$ per timestamp. But here, ties and NaNs matter because they are common in minute bars and they bias rank statistics if you drop or rank incorrectly. You need per-minute filtering, tie-aware ranking, and a guardrail for small cross sections. Then aggregate, usually with a simple mean and a count of valid minutes.

import numpy as np


def _rankdata_average_ties(a: np.ndarray) -> np.ndarray:
    """Return 1..n ranks with average ranks for ties, NaNs preserved as NaN."""
    a = np.asarray(a, dtype=float)
    n = a.size
    ranks = np.full(n, np.nan)

    finite_idx = np.where(np.isfinite(a))[0]
    if finite_idx.size == 0:
        return ranks

    vals = a[finite_idx]
    order = np.argsort(vals, kind="mergesort")  # stable
    sorted_idx = finite_idx[order]
    sorted_vals = vals[order]

    # Walk runs of equal values.
    i = 0
    while i < sorted_vals.size:
        j = i
        while j + 1 < sorted_vals.size and sorted_vals[j + 1] == sorted_vals[i]:
            j += 1
        # Average rank for positions i..j in 1-based rank space.
        avg_rank = (i + 1 + j + 1) / 2.0
        ranks[sorted_idx[i : j + 1]] = avg_rank
        i = j + 1

    return ranks


def spearman_ic_by_minute(x: np.ndarray, r_next: np.ndarray, min_names: int = 5):
    """Compute per-minute Spearman rank IC and overall mean IC.

    Parameters
    ----------
    x : np.ndarray
        Shape (T, N) features at minute t.
    r_next : np.ndarray
        Shape (T, N) next-minute returns aligned so r_next[t] is r_{t+1}.
    min_names : int
        Minimum number of valid names required to compute IC for a minute.

    Returns
    -------
    ic_t : np.ndarray
        Shape (T,) IC per minute, NaN where undefined.
    mean_ic : float
        Mean IC over valid minutes.
    valid_minutes : np.ndarray
        Boolean mask over T.
    """
    x = np.asarray(x, dtype=float)
    r_next = np.asarray(r_next, dtype=float)
    if x.shape != r_next.shape or x.ndim != 2:
        raise ValueError("x and r_next must be 2D arrays with the same shape (T, N)")

    T, N = x.shape
    ic_t = np.full(T, np.nan)
    valid_minutes = np.zeros(T, dtype=bool)

    for t in range(T):
        xt = x[t]
        rt = r_next[t]
        ok = np.isfinite(xt) & np.isfinite(rt)
        if ok.sum() < min_names:
            continue

        rx = _rankdata_average_ties(xt)
        rr = _rankdata_average_ties(rt)
        # Restrict to valid names (ranks are NaN where invalid).
        ok2 = np.isfinite(rx) & np.isfinite(rr)
        if ok2.sum() < min_names:
            continue

        a = rx[ok2]
        b = rr[ok2]

        # Pearson correlation of ranks.
        a0 = a - a.mean()
        b0 = b - b.mean()
        denom = np.sqrt((a0 * a0).sum() * (b0 * b0).sum())
        if denom <= 0:
            continue

        ic_t[t] = float((a0 * b0).sum() / denom)
        valid_minutes[t] = True

    mean_ic = float(np.nanmean(ic_t)) if np.any(valid_minutes) else np.nan
    return ic_t, mean_ic, valid_minutes


if __name__ == "__main__":
    rng = np.random.default_rng(0)
    T, N = 4, 6
    x = rng.normal(size=(T, N))
    r = rng.normal(size=(T, N))
    x[0, 1] = np.nan
    r[2, 3] = np.nan
    x[1, :] = 1.0  # ties

    ic_t, mean_ic, vm = spearman_ic_by_minute(x, r)
    print(ic_t)
    print(mean_ic)
    print(vm)

You are building a next-5-minute return model using minute bars and a feature pipeline that includes rolling means and cross-sectional ranks. Write code that produces walk-forward splits with an embargo of $E$ minutes around each test block, and verify in code that no training row uses any timestamp in the forbidden region.

CitadelHardTime Series Cross-Validation

Sample Answer

Unlock the full solution

View detailed answers and practice in our question bank

View Solution

Practice more ML Coding & Implementation questions

The split between probability, statistics, mathematics, and math (linear algebra, optimization) on one side and coding, ML modeling, and ML implementation on the other is closer to even than most candidates assume. Where it gets painful is onsite rounds that blend both halves: you derive a ridge penalty's gradient analytically, then open a blank Python file and implement the optimizer before time runs out. The prep mistake this distribution screams at you is over-indexing on brainteaser collections while barely touching the 32% of questions that require you to write real code under pressure.

Practice quant-calibrated questions across all eight areas at datainterview.com/questions.

How to Prepare

Probability and statistics deserve outsized prep time relative to other areas. They account for roughly a third of all questions, and from what candidates report, these rounds have the steepest penalty for hesitation. Spend weeks 1-2 working through Mark Joshi's "green book" and Heard on the Street, but pair each puzzle with a full derivation using Bayes' theorem, conditional expectation, or generating functions so you internalize the reasoning, not just the answer.

Layer in hypothesis testing (power analysis, multiple comparisons via Bonferroni/BH) and distribution theory (conjugate priors, moment-generating functions) during those same two weeks. Weeks 3-4, solve one medium-hard algorithm problem daily in Python or C++, targeting dynamic programming, graph search, and numerical methods like Newton-Raphson. For ML, implement logistic regression's update rule, k-fold cross-validation, and a gradient boosted tree from scratch without importing sklearn.

Weeks 5-6, run two or three full case studies end-to-end: engineer features like rolling volatility and order flow imbalance from publicly available equity data (Yahoo Finance daily bars work fine), backtest a simple mean-reversion signal, then estimate its Sharpe ratio net of transaction costs. This is where generalist data scientists consistently fail the quant loop, because they've never had to connect a model's predictions to a PnL statement with realistic slippage and commission assumptions.

Try a Real Interview Question

from typing import Iterable, Tuple


def score_forecasts(ps: Iterable[float], ys: Iterable[int], eps: float = 1e-15) -> Tuple[float, float]:
    """Compute mean negative log loss and mean Brier score for binary forecasts.

    Args:
        ps: Iterable of predicted probabilities.
        ys: Iterable of realized outcomes, each 0 or 1.
        eps: Clipping parameter for probabilities.

    Returns:
        (mean_logloss, mean_brier)
    """
    pass

from typing import Iterable, Tuple
import math


def score_forecasts(ps: Iterable[float], ys: Iterable[int], eps: float = 1e-15) -> Tuple[float, float]:
    """Compute mean negative log loss and mean Brier score for binary forecasts.

    Args:
        ps: Iterable of predicted probabilities.
        ys: Iterable of realized outcomes, each 0 or 1.
        eps: Clipping parameter for probabilities.

    Returns:
        (mean_logloss, mean_brier)

    Raises:
        ValueError: If inputs have different lengths, are empty, eps is invalid,
            or ys contains values other than 0 or 1.
    """
    if not (0.0 < eps < 0.5):
        raise ValueError("eps must satisfy 0 < eps < 0.5")

    it_p = iter(ps)
    it_y = iter(ys)

    n = 0
    sum_logloss = 0.0
    sum_brier = 0.0

    while True:
        try:
            p = next(it_p)
        except StopIteration:
            try:
                next(it_y)
                raise ValueError("ps and ys must have the same length")
            except StopIteration:
                break

        try:
            y = next(it_y)
        except StopIteration:
            raise ValueError("ps and ys must have the same length")

        if y not in (0, 1):
            raise ValueError("ys must contain only 0 or 1")

        if not math.isfinite(p):
            raise ValueError("ps must contain finite floats")

        p = min(1.0 - eps, max(eps, float(p)))

        sum_logloss += -(y * math.log(p) + (1 - y) * math.log(1.0 - p))
        diff = p - y
        sum_brier += diff * diff
        n += 1

    if n == 0:
        raise ValueError("inputs must be non-empty")

    return (sum_logloss / n, sum_brier / n)

Quant coding rounds reward recognizing mathematical structure (convexity, recurrence relations, Lagrangian relaxation) over brute-force pattern matching. Practice more problems calibrated to this difficulty at datainterview.com/coding.

Test Your Readiness

Timed practice is the closest simulation of the speed expected in probability and statistics rounds. Find more questions at datainterview.com/questions.