Optiver 2026 New Grad OA 全流程解析｜HackerRank 程式設計 + 知識測驗 + Zap-N 遊戲真實體驗

1,631Views

尚無留言

Optiver 2026 New Grad 的 Online Assessment 整體強度不低，不是單純刷 LeetCode 就能穩過的型別。
這套 OA 更像是在測試：

你是否具備成為量化交易系統工程師所需要的工程思維、系統理解能力，以及高壓環境下的穩定性。

下面將從 OA 結構 → 每一部分的真實題型 → 重點難點 → 面試銜接，完整拆解 Optiver 26 NG OA。

Optiver OA 總體結構概覽

Optiver 25 NG OA 通常由 三大部分 組成：

HackerRank 程式設計測試（2 題）
Programming Knowledge Test（20 分鐘選擇題）
Optiver Zap-N 遊戲測評（60 分鐘）

這三部分並不是獨立存在的，而是從不同角度評估同一個人。

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

要求構建一個日誌伺服器，用於處理大量的日誌訊息。每條訊息包含一個唯一的整數日誌 ID 和一個整數時間戳。我們的伺服器由於儲存限制，只能在傳入請求時返回一小時內的最多 m 條最新日誌。

需要實現三個方法：

recordLog(logId, timestamp)：根據日誌Id記錄日誌。
getLogs()：返回的整數列表中應包含前一小時最多的 m 條日誌 ID，按時間戳升序列出。如果時間戳相同，則順序為記錄到日誌伺服器的順序。
getLogCount()：返回最近一小時內的日誌總量。

樣例輸入
100 10 RECORD 1 0 RECORD 2 300 COUNT RECORD 3 1200 RECORD 1 1800 GET_LOGS COUNT RECORD 4 3900 GET_LOGS

樣例輸出
1,2 1,2,3,1 4

class LogServer:
    def __init__(self, m):
        self.logs_dict = {}  # 儲存日誌ID及其時間戳
        self.m = m  # 最大日誌數量限制
        self.log_ids_queue = []  # 儲存最近m個日誌ID的佇列
    def recordLog(self, logId, timestamp):
        # 更新日誌ID的時間戳
        if logId in self.logs_dict:
            self.logs_dict[logId].append(timestamp)
        else:
            self.logs_dict[logId] = [timestamp]
        # 更新日誌ID佇列
        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):
        # 返回最近一小時內的最新m個日誌ID
        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):
        # 返回最近一小時內的日誌總數
        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

給定一個程序列表，每個程序都有一個唯一的PID（程序識別符號）、開始時間和結束時間。此外還有一組程序之間的依賴關係。排程器只能在整數時間單位上安排程序的開始或結束，例如1、2、1000、999999等，而不是1.5、700.1等非整數值。

任務是實現一個Scheduler類，包含建構函式和PrintSchedule方法。建構函式接受程序列表和依賴關係，PrintSchedule方法不帶任何引數。

樣例輸入：1 2 100 2100 110 2200 200 2330 1 2 2 2

樣例輸出：1 100 110 200 2100 2200 2330

思路：

為了解決這個問題，我們可以使用拓撲排序。首先，我們需要計算每個程序的最晚開始時間，即它必須在其所有依賴項完成之後才能開始。然後，我們可以使用拓撲排序來確定正確的程序執行順序。最後，我們將找到滿足所有約束條件的最大持續時間即可。

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面試：

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?