
I just completed the BNP Paribas Quantitative Finance OA. The test was on HackerRank and allowed 90 minutes for completion. There were six questions in total, five focusing on math, probability, and algorithm complexity analysis, and one programming question. Overall, the questions were fairly basic and the time was sufficient. However, the programming question involved string manipulation, which was somewhat uncommon.
I am really grateful for the tool Linkjob.ai, and that's also why I'm sharing my entire OA interview experience here. Having an undetectable AI assistant during the interview is indeed very convenient.
There are four blood types, each equally likely. The task is to find the expected number of people needed to collect all types.
Formula: E = n * (1 + 1/2 + 1/3 + ... + 1/n)
Here n = 4:
E = 4 * (1 + 1/2 + 1/3 + 1/4) = 4 * 25/12 ≈ 8.33
Round up → answer is 9.

Compute the integral: ∫(0 to 2π) cos(x) * cos(2x) * cos(3x) * cos(4x) * cos(5x) * cos(6x) dx
Use the orthogonality property of cosines: for integer k ≠ 0, ∫(0 to 2π) cos(k*x) dx = 0; only when k = 0 is the integral 2π.
Expanding the product of cosines gives terms of the form cos(m*x) with m ≠ 0. Hence all terms integrate to 0. Final answer: 0.


Given a 4x4 matrix A with det(A) = 5, find det(2A).
Property: for an n x n matrix, det(k*A) = k^n * det(A)
Here n = 4 and k = 2:
det(2A) = 2^4 * 5 = 16 * 5 = 80
Answer: 80.


This is a string processing problem. Convert a polynomial string into a coefficient array [a0, a1, ..., an] with 5 decimal places.
My approach was:
Preprocess: remove spaces, fix signs (e.g., x^2 → 1x^2, -x^3 → -1x^3).
Split terms by + and - while keeping track of signs.
Parse each term into coefficient and exponent:
x^2 → coeff 1, exp 2
-3x^3 → coeff -3, exp 3
4 → coeff 4, exp 0
Build coefficient array of length (highest exponent + 1) and fill coefficients.
Format each value to 5 decimal places.
Example: input "x^2 - 3x^3 + 4" → array [4.00000, 0.00000, 1.00000, -3.00000].

I have to say, Linkjob AI is really easy to use. I used it during the interview after testing its undetectable feature with a friend beforehand. With just a click of the screenshot button, the AI provided detailed solution frameworks and complete code answers for the coding problems on my screen. I’ve successfully passed the test, with the HackerRank platform not detecting me at all.


Code Fragment A: insertion sort. Worst case (reverse sorted array) → time complexity O(N^2).
Code Fragment B: binary search.
Worst case → O(log N)
Best case → O(1)

Calculate forward price of a stock with dividend.
Formula: Forward Price = FV of Spot - FV of Dividend
Given: Spot S0, risk-free rate r, dividend d after 6 months, forward term T = 1 year.
Spot FV: S0 * exp(r*T) (continuous compounding)
Dividend FV: d * exp(r*(T - Td)), here Td = 0.5 years
Forward price: F(T) = S0 * exp(r*T) - d * exp(r*(T - Td))
Answer: choose the first option.
Test Duration
The total time is 90 minutes. There is no strict per-question time limit, and time can be freely allocated among the questions.
Test Platform
The test is conducted entirely on the HackerRank website with no additional software installation required. After receiving the invitation email, click the link to access the test page. It is recommended to log in 10 minutes early to check network stability and browser compatibility (Chrome or Firefox recommended) to avoid technical issues.
Number and Type of Questions
There are 6 questions in total, divided into three main types:
Objective Questions (4): probability and statistics, trigonometry/integration, matrix determinants, algorithm complexity analysis, and financial derivatives (choose 4 out of 5, covering math, finance, and basic algorithm knowledge).
Subjective Programming Question (1): string processing (e.g., extracting coefficients from a polynomial).
Mixed Question (1): code fragment analysis, including multiple-choice selections and complexity evaluation.
Programming Language Support
The programming question supports major languages. Python was chosen for the test, but options include Java, C++, JavaScript, C#, etc. Candidates can select the language they are most comfortable with. No additional environment setup is needed, as HackerRank provides an online editor and automated test cases.
The test does not emphasize “trick questions” or overly obscure problems. The focus is on three main abilities:
Fundamental Knowledge: mathematics (probability, integration, linear algebra) and basic financial derivatives (forwards, dividend adjustments).
Practical Programming Skills: string handling, edge case management, and debugging.
Algorithmic Thinking: identifying classic algorithms and analyzing time complexity (no complex algorithm design required, focus on fundamental application).
Focus on probability, combinatorics, and basic statistics.
Practice integrals and trigonometric identities for common calculations.
Brush up on linear algebra concepts, including determinants and matrix operations.
Learn forward pricing, dividend adjustments, and basic equity derivative calculations.
Focus on the underlying logic rather than complex formulas.
Refresh skills in parsing and manipulating strings efficiently.
Pay attention to edge cases and input validation.
Practice implementing solutions in a chosen programming language (Python, Java, etc.) on HackerRank or similar online editors.
Allocate time to each question according to familiarity and complexity.
Avoid spending too long on one question; ensure all questions receive attention.
For coding problems, aim to implement a working solution first, then optimize if time allows.
Review basic algorithm patterns: greedy, sorting, searching, and simulation.
Practice calculating time complexity for simple algorithms.
Focus on recognizing patterns rather than designing advanced algorithms.
Take timed practice tests on HackerRank to become familiar with the interface.
Ensure comfort with the coding environment, compiling, and running test cases.
Double-check for off-by-one errors or misinterpreted problem statements.
Handle large inputs carefully to avoid timeouts.
Verify formulas and calculations before submitting answers.
Scan all questions at the start.
Solve the ones with familiar concepts or straightforward calculations first to secure quick points.
For probability or combinatorics questions, identify key variables and relationships.
Translate word problems into formulas step by step.
For string or array manipulation, plan parsing logic before coding.
Test with small sample inputs before scaling to larger datasets.
Allocate roughly equal time per question, leaving a buffer for the programming task.
If stuck, move on and return later with fresh perspective.
Consider minimum, maximum, and unusual inputs.
For programming problems, include empty strings, zero values, and boundary numbers.
Write comments or pseudo-code for complex formulas.
Helps avoid mistakes and makes reviewing easier under time pressure.
For expected value, determinants, and integrals, use standard formulas or properties to simplify calculations.
Avoid unnecessary expansion or brute force approaches.
I got my results about a week after I finished the test. If you do not hear back in a week, you can reach out to the recruiter.
Yes, I could choose from several languages like C++, Java, and Python. I suggest you use the language you feel most comfortable with. That helped me code faster and with fewer mistakes.
My Strategy For Excelling In The BCG X Assessment
Successfully Navigating My Palantir New Grad Interview
Insights From My Databricks New Grad Interview Journey