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 + 前缀异或。

为什么这道题对 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