Optiver Software Engineer Interview Questions

Hey, I recently passed the behavioral phone call with Optiver and am now preparing for the technical round. While I expect the focus to be on DSA, I want to prep a little system design too. I have not

3 coding questions, 1.5 hours The following content requires a score higher than 200. You can already view it. Q1: Given n, k, m; n is the number of shares you want to hold, k is the number of shares

The OA (Online Response Assessment) for Optimizer has three parts. Here's a sample coding question from the first part. A friend of mine also applied and encountered a question similar to the hot air

A satellite network is experimenting with a distributed communication protocol based on satellite connections. During system tests, the team wants to ensure that messages they sent are processed in the correct...

I received my Optiver OA assessment link last week, which contains three sections (in this post, I just want to talk about the coding part). The coding section consists of two questions (mostly OOP) w

Truck Positions A logistics company has a central software solution to track the position of their trucks. Different applications are interested in different trucks. To save bandwidth the company wants to...

The OA was for Software Engineer Internship 2024 and below is the second question from it. # Concert Tickets ## Problem Statement As a long time live-music fan you have kept a bucket...

The OA was for Software Engineer Internship 2024 and below is the second question from it. Concert Tickets Problem Statement As a long time live-music fan you have kept a bucket list of...

Has anyone interviewed for Optiver in Amsterdam? I am curious about the type of questions they ask at the technical onsite interview. Should I be expecting data structures and algorithmic problems, or

LeetCode #622: Design Circular Queue. Difficulty: Medium. Topics: Array, Linked List, Design, Queue. Asked at Optiver in the last 6 months.

LeetCode #1206: Design Skiplist. Difficulty: Hard. Topics: Linked List, Design. Asked at Optiver in the last 6 months.

LeetCode #146: LRU Cache. Difficulty: Medium. Topics: Hash Table, Linked List, Design, Doubly-Linked List. Asked at Optiver in the last 6 months.

## Problem You are given an encoded array `diff` of length `n-1` where `diff[i] = original[i+1] - original[i]`. You are also given `original[0]`. Reconstruct and return the full original array. ```python def reconstruct(first: int, diff: list[int]) -> list[int]: pass ``` **Example:** ``` Input: first = 3, diff = [2, -1, 4] Output: [3, 5, 4, 8] Explanation: 3 3 + 2 = 5 5 + (-1) = 4 4 + 4 = 8 ``` ## Round 2 - Follow-up Variant Now you are given the array in shuffled order and the difference array in shuffled order, but you are NOT given `original[0]`. Determine if a valid reconstruction exists. If yes, return one valid original array. ```python def can_reconstruct(shuffled: list[int], diff_shuffled: list[int]) -> list[int] | None: pass ``` ## Follow-ups 1. What is the time and space complexity of your reconstruction? 2. In the shuffled variant, how many possible starting values are there to check? 3. How would you handle floating-point differences with precision errors? 4. Extend to 2D: reconstruct a matrix from row and column difference arrays.

## Problem Implement a circular queue (ring buffer) with enqueue and dequeue operations, handling wrap-around indices. ## Likely LeetCode equivalent LC 622 - design-circular-queue ## Tags queue, design, arrays

## Round 1 - Fundamentals Q&A **Operating Systems:** - What is the difference between a process and a thread? - Explain how virtual memory works. What happens on a page fault? - What is a deadlock? State the four necessary conditions. **Networking:** - Walk me through what happens when you type `https://example.com` in a browser and hit Enter. - What is the difference between TCP and UDP? When would you choose UDP? - What does a 3-way handshake accomplish? **Data Structures:** - When would you choose a hash map over a BST? - Explain how a consistent hash ring works. **Concurrency:** - What is a race condition? Give an example. - How does a mutex differ from a semaphore? ## Round 2 - Coding Warm-up Implement a thread-safe counter in Python using a lock. ```python import threading class SafeCounter: def __init__(self): ... def increment(self): ... def value(self) -> int: ... ``` ## Follow-ups 1. How would you detect a deadlock at runtime in a production system? 2. Explain cache coherence in a multi-core CPU. 3. What tradeoffs do you make when choosing between optimistic and pessimistic locking? 4. How does Python's GIL affect your thread-safe counter?

## Problem Group or retrieve favorite songs by some criteria, likely using hash maps or sorting to find most-played or top-rated songs. ## Tags hash_table, arrays, sorting

## Problem You are given two integers `a` and `b` and a prime modulus `p`. Compute `(a^b) mod p` efficiently. Then: given an array of `n` integers, compute the product of all elements modulo `p`, but skip any element that is divisible by `p`. ```cpp long long mod_exp(long long base, long long exp, long long mod); long long filtered_product(vector<long long>& arr, long long p); ``` **Example:** ``` mod_exp(2, 10, 1000000007) -> 1024 filtered_product([2, 3, 7, 14, 5], 7) skip 7 and 14 (divisible by 7) -> (2 * 3 * 5) % 7 = 30 % 7 = 2 ``` ## Follow-ups 1. What is the time complexity of fast exponentiation? How does it compare to naive exponentiation for b = 10^18? 2. By Fermat's little theorem, what is `a^(p-1) mod p` when p is prime and gcd(a,p)=1? How can this simplify computing modular inverses? 3. If `p` is not prime, does your approach still work? What changes? 4. Implement `mod_exp` iteratively (no recursion) to avoid stack overflow for large exponents.

## Problem Simulate a simplified limit order book. You receive a stream of orders: each order is `{id, side, price, quantity}` where `side` is `"buy"` or `"sell"`. - Buy orders are matched against the lowest-priced sell order at or below the buy price. - Sell orders are matched against the highest-priced buy order at or above the sell price. - On price tie, earlier orders have priority (FIFO). - Unmatched remainder stays in the book. After processing all orders, return the remaining orders in the book grouped by side. ```python def process_orders(orders: list[dict]) -> dict: # returns {"buy": [...], "sell": [...]} pass ``` **Example:** ``` Input: [{id:1, side:"sell", price:100, qty:5}, {id:2, side:"buy", price:102, qty:3}, {id:3, side:"buy", price:99, qty:2}] Order 2 matches order 1 for qty=3 @ price=100. Sell order 1 has 2 remaining. Order 3 (buy @99) cannot match sell @100. Output: {"buy": [{id:3,...}], "sell": [{id:1, qty:2,...}]} ``` ## Follow-ups 1. Which data structure gives you O(log n) insert and O(1) best-price lookup for each side? 2. How would you handle partial fills and order cancellations? 3. At 1 million orders/second, where are the bottlenecks in your implementation? 4. How would you persist the order book state across system restarts?

## Problem Allocate orders to slots or resources optimally, likely a greedy or DP scheduling problem. ## Tags greedy, dynamic_programming, arrays

## Problem Maintain a leaderboard of top orders by volume or priority, likely using a heap or sorted structure for efficient top-k queries. ## Tags heap, sorting, design