Optiver The overall strength of the 2026 New Grad Online Assessment is not low, and it is not a type that can be passed simply by brushing LeetCode.
This set of OA is more like testing:
Do you have the engineering thinking, system understanding, and stability in a high-pressure environment required to become a quantitative trading system engineer?
The following will completely dismantle the Optiver 26 NG OA from the OA structure → the actual question types of each part → the key and difficult points → the interview connection.
Optiver OA overall structure overview
Optiver 25 NG OA is usually made of Three parts Composition:
- HackerRank Programming Test (2 questions)
- Programming Knowledge Test (20 minutes multiple choice questions)
- Optiver Zap-N Game Review (60 minutes)
These three parts do not exist independently, but evaluate the same person from different perspectives.
Optiver Online Assessments 1 HackerRank test + more Here is a detailed breakdown:
- HackerRank Code:
- Code 1: LeetCode style questions in the medium to easy range. However, only that types of problem but solutions are not present worldwide.
- Code 2: Object-Oriented Design (OOD) Problem Statement: It is a longish problem statement and one needs to read it carefully.
- Programming Knowledge Test:
- Duration: 20 minutes.
- About 20 multiple-choice questions.
- Topics like data structures, system design and operating systems.
- Optiver Zap-N Game:
- Duration: 60 minutes
- 9 mini-games (Between 2–15 mins each), If you can, use a mouse for these games.
- Balloon challenge, code comparison and number blocks were the games they had.
Optiver OA 1
It is required to build a log server to handle a large number of log messages. Each message contains a unique integer log ID and an integer timestamp. Due to storage limitations, our server can only return up to the m latest logs within an hour on incoming requests.
Three methods need to be implemented:
recordLog(logId, timestamp): Record logs based on log ID.GetLogs(): The returned integer list should contain the most m log IDs in the previous hour, listed in ascending order of timestamp. If the timestamps are the same, the order is the order logged to the log server.GetLogCount(): Returns the total amount of logs in the last hour.
Sample input100
10
RECORD 1 0
RECORD 2 300
COUNT
RECORD 3 1200
RECORD 1 1800
GET_LOGS
COUNT
RECORD 4 3900
GET_LOGS
Sample output1,2
1,2,3,1
4
ClassLogServer:
def __init__(self, m):
self.logs_dict = {} # Store log ID and its timestamp
self.m = m # Maximum log number limit
self.log_ids_queue = [] # Queue that saves the latest m log IDs
def recordLog(self, logId, timestamp):
# Update timestamp of log ID
if logId in self.logs_dict:
self.logs_dict[logId].append(timestamp)
else:
self.logs_dict[logId] = [timestamp]
# Update log ID queue
while len(self.log_ids_queue) >= self.m:
oldest_log_id = self.log_ids_queue.pop(0)
del self.logs_dict[oldest_log_id]
self.log_ids_queue.append(logId)
def getLogs(self):
# Return the latest m log IDs in the last hour
current_time = time.time()
one_hour_ago = current_time - 3600
sorted_logs = sorted(
self.logs_dict.items(),
key=lambda x: (x[1][-1], self.logs_dict[x[0]][-1])
)
recent_logs = [
logId for logId, timestamps in sorted_logs
if timestamps[-1] > one_hour_ago
]
return ",".join(str(logId) for logId in recent_logs[:self.m])
def getLogCount(self):
# Return the total number of logs in the last hour
current_time = time.time()
one_hour_ago = current_time - 3600
return sum(
len(timestamps)
for logId, timestamps in self.logs_dict.items()
if timestamps[-1] > one_hour_ago
)Optiver OA 2
Given a list of processes, each process has a unique PID (process identifier), start time, and end time. There is also a set of dependencies between processes. The scheduler can only schedule the start or end of a process on integer time units, such as 1, 2, 1000, 999999, etc., not non-integer values such as 1.5, 700.1, etc.
The task is to implement a Scheduler class, including the constructor and PrintSchedule method. The constructor accepts a list of processes and dependencies, and the PrintSchedule method takes no parameters.
Sample input:1 2 100 2100 110 2200 200 2330 1 2 2 2
Sample output:1 100 110 200 2100 2200 2330
Idea:
To solve this problem, we can use topological sorting. First, we need to calculate the latest start time of each process, i.e. It must not start until all its dependencies have completed. We can then use topological sorting to determine the correct order of process execution. Finally, we will find the maximum duration that satisfies all constraints.
Import heapq
class Scheduler:
def __init__(self, processes, dependencies):
self.processes = {pid: (start, end) for pid, start, _ in processes}
self.dependencies = dependencies
self.in_degrees = {
pid: 0 for pid in range(1, max(self.processes.keys())+1)
}
for dep in dependencies:
self.in_degrees[dep[1]] += 1
self.schedule = []
def PrintSchedule(self):
self.topological_sort()
earliest_start = min(p[0] for p in self.processes.values())
latest_end = max(p[1] for p in self.processes.values())
duration = latest_end - earliest_start
print(*sorted(pid for pid in self.schedule), sep=" ")
def topological_sort(self):
queue = []
for pid, (_, end) in self.processes.items():
if self.in_degrees[pid] == 0:
heapq.heappush(queue, (-end, pid))
while queue:
_, pid = heapq.heappop(queue)
self.schedule.append(pid)
for dependent in self.dependencies.get(pid, []):
self.in_degrees[dependent] -= 1
if self.in_degrees[dependent] == 0:
heapq.heappush(
queue, (-self.processes[dependent][1], dependent)
)
@staticmethod
def read_input():
n_p, n_d = map(int, input().split())
processes = [tuple(map(int, input().split())) for _ in range(n_p)]
dependencies = [tuple(map(int, input().split())) for _ in range(n_d)]
return processes, dependencies
def run_all_test_cases(self):
t = int(input())
for _ in range(t):
processes, dependencies = self.read_input()
Scheduler(processes, dependencies).PrintSchedule()
if __name__ == "__main__":
Scheduler([], []).run_all_test_cases()Recruiter interview:
- Education background confirmation. Sponsorship.
- Why this position, why quantitative trading?
- Why Optiver?
- Do you have something that you have been sticking to for years?
- Can you tell me a period (from your internships) that you receive bad remarks?
- What are their potential competing candidates and other companies that they should pay attention to?
- What are the key factors you pay attention to when choosing companies?
- Which office prefer? Chicago or Houston?
Learn More
Optiver OA Leetcode – Senior Software Engineer
Glassdoor: Optiver OA Question
Optiver Intern OA summer 24 Reddit
Optiver 2026 has started, are you ready to face the challenge of hell-level OA?
Still worried about the lengthy OOD questions on HackerRank? Still blank in front of CodeSignal’s countdown? We provide professional writing services for mainstream platforms such as HackerRank, Niuke.com, CodeSignal, and Codility:
- The whole case passed: Senior algorithm experts are in charge to ensure that 100% of the Test Cases pass, and there will be no charge if they fail.
- Traceless operation: Exclusive remote technology implementation, physical isolation, avoiding platform monitoring, ensuring absolute account security.
- All question types covered: Whether it's LeetCode's hard-core algorithm, complex OOD architecture, or system design, it's all covered. Stop losing interview opportunities and open the door to big companies with perfect scores.
[Consult now, book your tickets to big factories]
