In this guide, we’ll break down some Optiver Quant Analyst interview questions, provide detailed solutions, and explain all the concepts involved. Let’s dive in.

Quant Interview Questions from Optiver — Solve and Explain

1. The Gambler’s Ruin: Doubling Down Strategy

Problem Statement

A person has 100 pounds to gamble. First, he will gamble 1 pound and if he wins, he will leave. Otherwise, he will gamble double next time until he wins. What is his profit from this game?

Understanding the Problem

This problem is a classic example of the Martingale betting strategy. The player starts with a 1-pound bet. If he loses, he doubles his bet each time (2, 4, 8, ...) until he wins. As soon as he wins, he leaves the game. The questions we need to answer are:

• What is the profit if he wins?
• Is this strategy foolproof?
• What are the mathematical expectations?

Step-by-Step Solution

Assumptions

• The probability of winning any single bet is 0.5 (fair coin).
• The gambler has an upper limit of 100 pounds.
• As soon as the gambler wins, he stops and collects his profit.

Sequence of Bets

Let’s denote each bet as \( B_n \), where \( n \) is the round number. The bets are:

• First bet: 1 pound
• Second bet: 2 pounds
• Third bet: 4 pounds
• Fourth bet: 8 pounds
• ...

Total money required after \( k \) losses is:

\[ \text{Total staked after k losses} = 1 + 2 + 4 + ... + 2^k = 2^{k+1} - 1 \]

He can keep doubling until his total staked equals or exceeds 100 pounds.

Maximum Number of Bets

Let’s find the maximum \( n \) such that:

\[ 2^{n+1} - 1 \leq 100 \]

Solving for \( n \): \[ 2^{n+1} \leq 101 \] \[ n+1 \leq \log_2(101) \approx 6.658 \] \[ n \leq 5.658 \] So, the maximum whole number is \( n = 5 \).

Let’s check:

• After 6 bets: \( 2^6 - 1 = 63 \) pounds
• After 7 bets: \( 2^7 - 1 = 127 \) pounds (exceeds 100)

Thus, the gambler can make at most 6 bets (0,1,2,3,4,5) — i.e., lose 5 times, and bet the 6th time.

Per-Round Analysis

Let’s look at the possible outcomes:

After losing 6 times, he would have staked a total of 63 pounds. If he loses all 6 bets, he loses 63 pounds, and cannot continue (as the next bet would have to be 64 pounds, which exceeds his bankroll).

Profit Calculation

If the gambler wins in any round, his profit is always 1 pound. This is because each bet is designed to recover all previous losses and add 1 pound profit.

Expected profit:

\[ E[\text{profit}] = \sum_{k=1}^{6} 1 \cdot P(\text{win at round k}) + (-63) \cdot P(\text{lose all 6 rounds}) \]

Probability of winning in round \( k \) is \( (0.5)^{k} \), and probability of losing all 6 bets is \( (0.5)^6 = 0.015625 \).

\[ E[\text{profit}] = \sum_{k=1}^{6} 1 \cdot (0.5)^k + (-63) \cdot (0.5)^6 \]

\[ \sum_{k=1}^{6} (0.5)^k = (0.5) + (0.25) + (0.125) + (0.0625) + (0.03125) + (0.015625) = 0.984375 \]

So, \[ E[\text{profit}] = 0.984375 - 63 \cdot 0.015625 = 0.984375 - 0.984375 = 0 \]

Conclusion

With a bankroll limit (here, 100 pounds), the expected profit is zero.

In other words, the Martingale strategy does not provide a positive expected return when you have a finite bankroll. If the gambler wins, the profit is always 1 pound per session, but if he loses 6 times in a row, he loses 63 pounds, wiping out his profit. Over time, the expected value is zero.

2. Designing an Algorithm for Optimal Trade Entry and Exit

Problem Statement

How would you build an algorithm to find the best time to enter and exit a trade?

Concepts Involved

• Price Signals — Using past price data to predict future movement.
• Technical Indicators — Tools like moving averages, RSI, MACD.
• Backtesting — Simulating the strategy on historical data.
• Risk Management — Setting stop-losses and take-profits.

Algorithm Design Steps

1. Choose the market and data (e.g., stock prices, tick data).
2. Identify features or signals for entry and exit (e.g., moving average crossover).
3. Define entry rule (when to buy or sell).
4. Define exit rule (when to close the position).
5. Test and optimize using historical data.

Example: Moving Average Crossover Strategy

A popular approach is the Moving Average Crossover:

• Buy when the short-term moving average crosses above the long-term moving average.
• Sell when the short-term moving average crosses below the long-term moving average.

Python Implementation

import pandas as pd

def moving_average_crossover(prices, short_window=20, long_window=50):
    signals = pd.DataFrame(index=prices.index)
    signals['price'] = prices
    # Calculate short-term and long-term moving averages
    signals['short_ma'] = prices.rolling(window=short_window, min_periods=1).mean()
    signals['long_ma'] = prices.rolling(window=long_window, min_periods=1).mean()
    # Generate signals: 1 for buy, -1 for sell
    signals['signal'] = 0
    signals['signal'][short_window:] = \
        np.where(signals['short_ma'][short_window:] > signals['long_ma'][short_window:], 1, 0)
    # Generate trading orders
    signals['positions'] = signals['signal'].diff()
    return signals

Explanation

• short_ma and long_ma — Rolling averages of prices.
• signal — 1 when short_ma > long_ma (buy signal), 0 otherwise.
• positions — Change in signal indicates entry (+1) or exit (-1).

Advanced Enhancements

• Add risk management (e.g., stop-loss, position sizing).
• Optimize parameters via backtesting.
• Combine multiple indicators (e.g., RSI, MACD).

General Algorithm Pseudocode

# Pseudocode for general entry/exit algorithm

for t in range(lookback, len(prices)):
    if entry_condition(prices, t):
        enter_trade()
    elif exit_condition(prices, t):
        exit_trade()
    manage_risk()

Summary

The key is to use a combination of data-driven signals and robust risk management to design a trading algorithm that maximizes expected return while minimizing risk.

3. K-Nearest Neighbor (KNN) Algorithm

Problem Statement

Write the algorithm for K-Nearest Neighbor (KNN).

Concepts Involved

• Supervised Learning — KNN is a supervised machine learning algorithm for classification and regression.
• Distance Metric — Measures similarity between data points (e.g., Euclidean distance).
• Majority Voting — For classification, label is determined by the majority of the nearest neighbors.

Step-by-Step KNN Algorithm

1. Choose the number of neighbors, \( k \).
2. Calculate the distance between the query point and all points in the training set.
3. Sort the distances and select the \( k \) closest points.
4. For classification: Assign the most common label among the \( k \) neighbors.
5. For regression: Take the mean of the \( k \) neighbors’ values.

Mathematics: Euclidean Distance

Given two points \( x = (x_1, x_2, ..., x_n) \) and \( y = (y_1, y_2, ..., y_n) \), the Euclidean distance is:

\[ d(x, y) = \sqrt{ \sum_{i=1}^{n} (x_i - y_i)^2 } \]

Python Implementation

import numpy as np
from collections import Counter

def knn_predict(X_train, y_train, x_query, k=3):
    # Compute distances from query to all training points
    distances = np.linalg.norm(X_train - x_query, axis=1)
    # Get indices of the k nearest neighbors
    k_indices = distances.argsort()[:k]
    # Get the labels of the nearest neighbors
    k_nearest_labels = y_train[k_indices]
    # Majority vote
    most_common = Counter(k_nearest_labels).most_common(1)
    return most_common[0][0]

Explanation

• X_train: Training data (features).
• y_train: Training labels.
• x_query: The data point to classify.
• k: Number of neighbors to consider.
• np.linalg.norm: Computes Euclidean distance.
• Counter: Determines the most common label among neighbors.

Advantages and Limitations

Improving KNN in Practice

• Feature Scaling: Apply normalization or standardization to ensure all features contribute equally to the distance calculation.
• Choosing Optimal k: Use cross-validation to select the best value of k for your dataset.
• Distance Metrics: Try other metrics like Manhattan (L1), Minkowski, or Mahalanobis for different types of data.
• Weighted Voting: Assign weights to neighbors based on their distance (e.g., closer neighbors have higher influence).
• Dimensionality Reduction: Techniques like PCA or t-SNE can reduce noise and improve efficiency.

Weighted KNN Example

Instead of simple majority voting, you can let closer neighbors have a larger say in the classification:

def weighted_knn_predict(X_train, y_train, x_query, k=3):
    distances = np.linalg.norm(X_train - x_query, axis=1)
    k_indices = distances.argsort()[:k]
    k_nearest_labels = y_train[k_indices]
    k_nearest_distances = distances[k_indices]
    # Avoid division by zero
    weights = 1 / (k_nearest_distances + 1e-5)
    label_weights = {}
    for label, weight in zip(k_nearest_labels, weights):
        label_weights[label] = label_weights.get(label, 0) + weight
    # Return label with highest total weight
    return max(label_weights, key=label_weights.get)

Summary of KNN

KNN is a powerful yet simple algorithm suitable for a variety of classification and regression tasks. In quantitative finance, KNN can be used for predicting market direction, clustering assets, and detecting anomalies in trading data.

4. Optiver Quant Analyst Interview: Additional Tips and Preparation

What Optiver Looks for in Quant Analyst Candidates

• Strong Analytical Skills: Ability to break down complex problems and reason quantitatively.
• Programming Proficiency: Especially in Python, C++, or Java—often tested through live coding or take-home assignments.
• Mathematical Rigor: Comfort with probability, statistics, combinatorics, and stochastic processes.
• Creativity: Thinking outside the box with novel approaches to puzzles or trading problems.
• Communication: Explaining your thought process clearly and methodically.

Common Quant Interview Topics

Sample Quant Interview Coding Problem

# Find the median of two sorted arrays
def find_median_sorted_arrays(nums1, nums2):
    nums = sorted(nums1 + nums2)
    n = len(nums)
    if n % 2 == 1:
        return nums[n//2]
    else:
        return (nums[n//2 - 1] + nums[n//2]) / 2

This type of problem tests your algorithmic thinking and ability to work with data efficiently.

5. Key Concepts Explained

Expectation in Probability

The expected value of a discrete random variable \( X \) is defined as: \[ E[X] = \sum_{i} x_i \cdot P(X = x_i) \] It represents the long-run average outcome if the process is repeated many times.

Backtesting Trading Strategies

Backtesting involves simulating your trading algorithm against historical data to gauge performance. Key metrics include Sharpe ratio, maximum drawdown, and win/loss ratio. Always use out-of-sample data for unbiased evaluation.

Feature Engineering for KNN

KNN’s performance depends on meaningful features. In finance, features might include:

• Price returns over different time windows
• Volatility measures (e.g., standard deviation of returns)
• Technical indicators (RSI, MACD, moving averages)
• Order book imbalance

6. Conclusion

Succeeding in an Optiver Quant Analyst interview requires more than just knowing formulas. You must be able to solve complex probability puzzles, design robust algorithms for trading, and demonstrate clear, logical reasoning.

In this guide, we’ve solved and explained three core questions:

• How the Martingale betting strategy works—and why the expected profit is still zero with a finite bankroll.
• How to design an algorithm for optimal trade entry and exit, using moving averages as an example.
• The step-by-step implementation and explanation of the K-Nearest Neighbor (KNN) algorithm.

Preparation is key: practice with a wide range of quantitative problems, strengthen your coding skills, and always be ready to explain your approach. With the right mindset and preparation, you’ll be well-equipped to ace your Optiver Quant Analyst interview.

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