NVIDIA HackerRank OA 高頻題型實錄：雙指針 + 滑動視窗 + 數論 + GPU 上下文背景題

NVIDIA 是 GPU 與 AI 加速器的代表，但它的 OA 題型並不像「寫 CUDA kernel」那樣花俏——大部分仍是 LeetCode Medium 級別的演算法題，少數職缺會再加 MCQ。重點是：NVIDIA HackerRank OA 的 hidden testcase 極嚴格，幾乎只看 AC 率。本文把 NVIDIA HackerRank OA 拆成 4 類題型，每類給一道高頻原題 + Python 解法。

OA 總覽

平台      HackerRank
時長      90 min（少數職缺 60 / 120 min）
題量      2-3 道程式；部分職缺再加 10 道 MCQ（C/C++ 語法、計算機組成）
通過線    ≥80% 測試案例 + 至少 1 題全 AC
評分      自動 + 人工複看
重考      6 個月內無法重投同一職缺

NVIDIA OA 沒有 CodeSignal 那樣的「實力分」體系，純看 hidden case 通過比例。這意味著邊界條件 + 大資料測試是必殺點。

題型 1 — 滑動視窗 / 雙指針

例題 1：K-th Smallest in Sliding Window

題面：給定陣列 nums 和視窗大小 k，每個視窗輸出第 t 小的元素。

from sortedcontainers import SortedList

def kth_smallest_window(nums: list[int], k: int, t: int) -> list[int]:
    sl = SortedList()
    out: list[int] = []
    for i, x in enumerate(nums):
        sl.add(x)
        if i >= k:
            sl.remove(nums[i - k])
        if i >= k - 1:
            out.append(sl[t - 1])
    return out

複雜度：O(n log k)。SortedList 的插入 / 刪除 / 索引都是 O(log k)。

踩坑：

• HackerRank 環境若沒裝 sortedcontainers，需改用 heapq 雙堆 + lazy deletion
• t 是 1-indexed 還是 0-indexed 一定要在題面裡讀清楚

例題 2：Subarray with Sum Divisible by K

題面：返回 nums 中和能被 k 整除的子陣列數量。

from collections import defaultdict

def subarrays_div_by_k(nums: list[int], k: int) -> int:
    cnt = defaultdict(int)
    cnt[0] = 1
    pre = 0
    ans = 0
    for x in nums:
        pre = (pre + x) % k
        ans += cnt[pre]
        cnt[pre] += 1
    return ans

複雜度：O(n)。前綴和模 k 餘數計數。

踩坑：負數取模要 (pre + x) % k，Python 的 % 對負數已自動正規化，但 C++ 要 ((pre + x) % k + k) % k。

題型 2 — 圖演算法 / Reachability

例題：Reachable Cities Within Cost C

題面：給定有向加權圖（邊表示距離），起點集合 S，問每個節點是否能在距離 ≤ C 內被某個起點到達。返回布林陣列。

import heapq

def reachable_within(n: int, edges: list[tuple[int, int, int]], starts: list[int], C: int) -> list[bool]:
    g: list[list[tuple[int, int]]] = [[] for _ in range(n)]
    for u, v, w in edges:
        g[u].append((v, w))
    dist = [float("inf")] * n
    pq: list[tuple[int, int]] = []
    for s in starts:
        dist[s] = 0
        heapq.heappush(pq, (0, s))
    while pq:
        d, u = heapq.heappop(pq)
        if d > dist[u] or d > C:
            continue
        for v, w in g[u]:
            nd = d + w
            if nd <= C and nd < dist[v]:
                dist[v] = nd
                heapq.heappush(pq, (nd, v))
    return [dist[i] <= C for i in range(n)]

複雜度：O(E log V)。多源 Dijkstra。

關鍵考點：能不能把 多源最短路 想成「初始堆裡有多個 0 起點」——這一思路 NVIDIA OA 經常出。

題型 3 — 數論 / 位運算

例題：Maximum XOR Subarray

題面：給定陣列，找出連續子陣列使 XOR 值最大。

class Trie:
    def __init__(self):
        self.children = {}

    def insert(self, num: int, bits: int = 32):
        node = self
        for i in range(bits - 1, -1, -1):
            b = (num >> i) & 1
            node = node.children.setdefault(b, Trie())

    def query(self, num: int, bits: int = 32) -> int:
        node = self
        ans = 0
        for i in range(bits - 1, -1, -1):
            b = (num >> i) & 1
            want = 1 - b
            if want in node.children:
                ans |= (1 << i)
                node = node.children[want]
            else:
                node = node.children[b]
        return ans

def max_xor_subarray(nums: list[int]) -> int:
    trie = Trie()
    trie.insert(0)
    pre = 0
    ans = 0
    for x in nums:
        pre ^= x
        ans = max(ans, trie.query(pre))
        trie.insert(pre)
    return ans

複雜度：O(n · 32) = O(n)。0/1 Trie + 前綴 XOR。

為什麼這道題對 NVIDIA 重要：GPU 工程師工作裡經常 bit-by-bit 算 mask，OA 出位運算題是常態。

題型 4 — GPU / 計算機組成 MCQ（部分職缺）

NVIDIA Drive / DGX / CUDA 編譯器職缺的 OA 會在程式題外加 10 道 MCQ，重點：

MCQ 高頻考點

1. C/C++ 記憶體模型：volatile / restrict / register 修飾符語意
2. 快取層次：L1 / L2 / shared memory / global memory 存取延遲比較
3. 平行模型：CUDA warp size = 32、SIMT vs SIMD 區別
4. 編譯器最佳化：-O2 與 -O3 在 loop unrolling 上的差異
5. 位運算：補碼 / 浮點 IEEE 754 編碼

例題

在 CUDA 中，__syncthreads() 的作用範圍是？ A. 整個 grid B. 整個 block C. 單個 warp D. 單個 thread

答案：B（block 內同步）。這是 CUDA 入門必考。

應對策略：

• 看完《CUDA C Programming Guide》前 3 章
• 把 NVIDIA Developer Blog 的 30 篇高讚文章掃一遍
• 不熟 CUDA 的候選人可以用「類比 OpenMP / MPI」的方式回答

四條職缺線的題型差異

職缺線	程式題主題	MCQ 比重
Drive / Auto	圖遍歷 + 狀態機	10%
DGX / Cloud	排程 + 平行	30%
Robotics / Edge	幾何 + 感測器融合	0%
Compiler / CUDA	位運算 + 數論	50%

OA 輔助 / OA 代面 怎麼對接 NVIDIA

NVIDIA HackerRank OA 沒法靠「平時刷 LC」蒙混過關——它的 hidden case 幾乎逐題命中邊界。OA 輔助 / OA 代面 標準節奏：

1. 職缺線判定：JD + recruiter 摘要 5 分鐘內判定 Drive / DGX / Robotics / Compiler
2. 90 min 限時模擬：兩套真題模擬，重點訓練 hidden case 思維（空陣列 / 極大值 / 單元素）
3. MCQ 速成：CUDA / C++ / 計算機組成各 50 題，按錯題率排序
4. HackerRank 環境模擬：本地用 Python 3.10 + 標準函式庫（不要帶 numpy / scipy），模擬無 sortedcontainers 時的 fallback
5. 現場 cue：onsite 當天後台推 hidden case 候選 + bit 運算 follow-up + Trie 範本

FAQ

Q1：NVIDIA OA 通過線是多少？ A：80% testcase + 1 題全 AC 是觀察值。低於 60% 幾乎必拒。

Q2：HackerRank 平台允許用 sortedcontainers 嗎？ A：取決於配置。建議提前在題目頂端 try import 一下，做好降級到 heapq 雙堆的 fallback。

Q3：NVIDIA OA 之後 review 週期多長？ A：通常 2-3 週。Drive / Robotics 職缺較快（1 週內有 recruiter 回饋），Compiler 職缺較慢（review 涉及多個 staff）。

Q4：MCQ 錯幾道還能過？ A：觀察值是 70% 以上正確率。MCQ 比重高的職缺（Compiler / CUDA），MCQ 占總分約 30%，不能放棄。

Q5：NVIDIA OA 能重做嗎？ A：不能。同一職缺 OA 失敗需間隔 6 個月才能再投，建議第一次就當真題打。

寫在最後

NVIDIA HackerRank OA 不靠刷題數量取勝，靠對 hidden case 的預判。每道題寫完，先想三個邊界（空 / 極小 / 極大），再交卷。如果你正在準備 NVIDIA OA，可以微信 Coding0201 聯繫，發職缺 JD + 當前流程節點截圖，先做職缺線判定，再排 OA 輔助 限時模擬節奏。

---

需要面試真題？ 立刻聯繫微信 Coding0201，獲取真題。

---

聯繫方式

• 微信：Coding0201
• Email: [email protected]
• Telegram: @OAVOProxy