In this comprehensive guide, we'll solve and deeply explain four real Citadel Securities quant interview questions. You'll find clear breakdowns of concepts, step-by-step solutions, and code implementations in Python. Let's dive into the types of problems you might encounter and master the underlying principles Citadel is testing for.

Quant Interview Questions from Citadel Securities: Solved with Explanations

1. Price an American Option via Backward Induction in Python

An American option is a financial derivative that can be exercised at any point up to and including its expiration date. This flexibility makes pricing American options more complex than European options, which can only be exercised at expiration. The standard method for pricing such options is backward induction using a binomial tree.

Binomial Tree Model: Key Concepts

• Underlying Assumptions:
  • The underlying asset price can move up or down by certain factors at each time step.
  • The process repeats for a set number of time steps.
  • At each node, the value of the option is the maximum of the immediate exercise value and the expected discounted value of continuation.
• Parameters:
  • \( S \): Initial stock price
  • \( K \): Option strike price
  • \( T \): Time to maturity (in years)
  • \( r \): Risk-free interest rate
  • \( \sigma \): Volatility
  • \( N \): Number of time steps
  • \( u, d \): Up and down factors
  • \( p \): Risk-neutral probability

Equations

• Time step: \( \Delta t = \frac{T}{N} \)
• Up factor: \( u = e^{\sigma \sqrt{\Delta t}} \)
• Down factor: \( d = e^{-\sigma \sqrt{\Delta t}} \)
• Risk-neutral probability: \[ p = \frac{e^{r \Delta t} - d}{u - d} \]
• Option value at each node: \[ V = \max(\text{exercise value}, \text{continuation value}) \] where \[ \text{continuation value} = e^{-r \Delta t} [pV_\text{up} + (1-p)V_\text{down}] \]

Python Implementation: American Put Option

import numpy as np

def american_option_binomial(S, K, T, r, sigma, N, option_type='put'):
    """
    Price an American option using a binomial tree.

    S: initial stock price
    K: strike price
    T: time to maturity (years)
    r: risk-free rate
    sigma: volatility
    N: number of time steps
    option_type: 'put' or 'call'
    """
    dt = T / N
    u = np.exp(sigma * np.sqrt(dt))
    d = np.exp(-sigma * np.sqrt(dt))
    p = (np.exp(r * dt) - d) / (u - d)

    # Initialize asset prices at maturity
    asset_prices = np.array([S * (u ** j) * (d ** (N - j)) for j in range(N + 1)])

    # Option values at maturity
    if option_type == 'put':
        option_values = np.maximum(K - asset_prices, 0)
    else:
        option_values = np.maximum(asset_prices - K, 0)

    # Backward induction
    for i in range(N - 1, -1, -1):
        asset_prices = asset_prices[:i+1] / u
        option_values = np.maximum(
            (np.exp(-r * dt) * (p * option_values[1:i+2] + (1 - p) * option_values[0:i+1])),
            K - asset_prices if option_type == 'put' else asset_prices - K
        )

    return option_values[0]

# Example usage:
price = american_option_binomial(S=100, K=100, T=1, r=0.05, sigma=0.2, N=100, option_type='put')
print(f"American Put Option Price: {price:.4f}")

Explanation

• We create a binomial tree where each node represents a possible price of the underlying asset.
• At each final node (maturity), we calculate the payoff of the option.
• We then move backward in time, at each node calculating the value as the maximum between immediate exercise and the discounted expected future value, accounting for the possibility of early exercise.
• This process continues until we arrive at the root, which gives the present value of the American option.

2. What Happens to R² if You Double Data in Regression? What About t-value?

This question tests your understanding of statistical measures in linear regression and how they respond to changes in sample size. Let’s explore both R-squared (\(R^2\)) and the t-value for regression coefficients when you double your dataset.

R-squared (\(R^2\))

\(R^2\) measures the proportion of variance in the dependent variable that is predictable from the independent variable(s).

Effect of Doubling Data

• If you double your dataset by collecting new, independent data: In expectation, \(R^2\) should stay roughly the same, assuming the new data is from the same distribution and the model remains appropriate. Any change in \(R^2\) would be due to sampling variability, not the mere increase in sample size.
• If you double the data by duplicating existing data: \(R^2\) remains exactly the same, because both the numerator and denominator in the formula scale proportionally.

t-value for Regression Coefficients

The t-value for a coefficient in linear regression is:

Standard error formula (for simple linear regression):

Effect of Doubling Data

• If you double your dataset by collecting new, independent data: The denominator (sum of squared deviations) roughly doubles, so the standard error decreases by a factor of \(\sqrt{2}\). Thus, the t-value increases by a factor of \(\sqrt{2}\), making your estimate more statistically significant.
• If you double the data by duplicating existing data: Both the coefficient and its standard error remain unchanged in their ratio, so the t-value remains the same.

Summary Table

3. Given Fair Dice, How Many Rolls Before Seeing All the Faces?

This probability puzzle is a classic example of the coupon collector's problem. The question: with a fair six-sided die, how many rolls on average are necessary to see every face at least once?

Coupon Collector’s Problem: General Solution

If there are \( n \) unique faces (or coupons), the expected number of trials to collect all \( n \) is:

Applied to a 6-sided Die

• Here, \( n = 6 \).
• \[ H_6 = 1 + \frac{1}{2} + \frac{1}{3} + \frac{1}{4} + \frac{1}{5} + \frac{1}{6} \approx 2.45 \]
• \[ E(6) = 6 \times 2.45 \approx 14.7 \]

So, on average, you need about 14.7 rolls to see all faces of a six-sided die.

Python Simulation

import numpy as np

def rolls_to_see_all_faces(n_faces=6, trials=100000):
    total_rolls = 0
    for _ in range(trials):
        seen = set()
        rolls = 0
        while len(seen) < n_faces:
            face = np.random.randint(1, n_faces + 1)
            seen.add(face)
            rolls += 1
        total_rolls += rolls
    return total_rolls / trials

print(f"Expected rolls for 6 faces: {rolls_to_see_all_faces():.2f}")

Generalization

For a die with \( n \) faces, the average number of rolls required to see all faces is \( n \cdot H_n \).

4. What Happens if Two Features Are Highly Co-linear in Lasso Regression?

This question explores the effect of multicollinearity (when predictor variables are highly correlated) in Lasso regression.

Lasso Regression: Key Concepts

• Lasso regression minimizes the usual sum of squared errors, but adds a penalty proportional to the sum of the absolute values of the coefficients.
• Cost function: \[ \min_{\beta_0, \beta} \left[ \sum_{i=1}^n (y_i - \beta_0 - X_i\beta)^2 + \lambda \sum_{j=1}^p |\beta_j| \right] \]
• The \( \lambda \) parameter controls the strength of regularization.

Effect of Highly Co-linear Features

• When two features are highly co-linear (strongly correlated), Lasso tends to assign a nonzero coefficient to only one of them and push the other(s) to exactly zero.
• This is due to the L1 penalty, which encourages sparsity in the coefficients.
• In practice, which feature is chosen to receive the nonzero coefficient can depend on slight differences in data or even on the implementation details of the solver.
• In contrast, Ridge regression (L2 regularization) tends to distribute the coefficients among collinear features rather than zeroing them out.

Visual Example in Python

import numpy as np
from sklearn.linear_model import Lasso

# Create highly collinear features
np.random.seed(42)
n_samples = 100
X1 = np.random.randn(n_samples)
X2 = X1 + np.random.normal(0, 0.01, n_samples)  # Highly collinear with X1
X3 = np.random.randn(n_samples)
X = np.vstack([X1, X2, X3]).T
y = 3*X1 + 2*X3 + np.random.randn(n_samples) * 0.1

lasso = Lasso(alpha=0.1)
lasso.fit(X, y)
print("Lasso coefficients:", lasso.coef_)

You’ll often observe that one of the collinear features (X1 or X2) gets a coefficient near zero, while the other keeps a nonzero value.

Summary Table

Conclusion

Citadel Securities quant interviews probe your grasp of both theoretical and practical aspects of quantitative finance and statistics. By mastering backward induction for American options, deeply understanding regression metrics, solving classic probability puzzles, and comprehending the nuances of regularization methods, you'll be well-prepared for the types of questions used to separate exceptional candidates from the rest. Practice these concepts, write code to simulate them, and always strive to explain why as well as how in your interviews.

Related Articles

• Quant Researcher Interview Questions from IMC Trading
• QRT Quant Researcher Interview Questions
• Quant Analyst Interview Questions from Five Rings
• Quant Analyst Interview Questions from Millenium
• Quant Research Interview Questions from D.E. Shaw