Roblox OA 在线测评考什么、怎么过（2026）

过了 Roblox 的在线测评，recruiter 才会联系你；没过，申请通常就到此为止。OA 是一轮限时、自动判分的编程初筛，近期候选人的反馈大多描述为 CodeSignal 风格的测评，面向软件工程和应届生岗位，不过平台和形式会随招聘周期变化。本指南只讲 OA 这一关：我们题库中 Roblox 真实测评出现过的题型、判题系统重点卡什么、为什么能过样例的代码仍然会挂，以及提交之后会发生什么。完整的面试流程请看我们的 Roblox 软件工程师面试指南和 Roblox 数据科学家面试指南。

核心要点

• 我们题库里的 Roblox OA 题目偏重实现的模拟题：会塌陷的网格、会走路的机器人、需要解析的日志。又快又对地写出 40–80 行代码，比掌握冷门算法更重要。
• 隐藏测试决定你的分数。一个能过可见样例、但在隐藏的大输入上跑出 O(n²)，或者在边界时间戳上出错的解法，会被直接判为失败，而且不会给出任何解释。
• 在我们题库里，Roblox 的 SWE 和 ML 筛选反复出现两种模式：窗口计数（hit counter、限流器）和数据流更新下的聚合。把这两种练到 deque 淘汰边界一写就对。
• 当输入约束说指令字符串会重复 10^9 次时，判题系统是在提示你去证明一个不变量，而不是去模拟。看出这个信号，比背任何模板都更有用。
• 平台、时长和题目数量每个周期都会变。历史上许多岗位是 CodeSignal 风格，但请以你收到的邀请邮件为准，而不是任何指南，包括这一篇。

Roblox OA 长什么样（以及对各种描述该信几分）

先说明一个限制，因为它很关键：在线测评的具体安排，是任何公司招聘流程里最不稳定的部分。下面的内容来自近期候选人的反馈和提交到我们题库的题目，并不能保证和你收到的邀请一致。

话虽如此，近期反馈中的规律是：Roblox 历史上会给软件工程师和应届生岗位发 CodeSignal 风格的测评。我们题库里有一份数据科学家测评，候选人明确描述为 CodeSignal 风格的环境，可以选 Python 或 R。CodeSignal 的 General Coding Assessment 历史上大约 70 分钟、四道难度递增的题目，我们的 CodeSignal OA 指南拆解了公司那边是怎么看这份评分报告的。如果你的邀请里写的是别的平台，我们的 Codility、HackerRank 与 CodeSignal 对比讲了作为候选人你需要注意哪些变化。

两点实用提醒。第一，CodeSignal 测评通常有屏幕和摄像头监考；规则相当具体，所以我们单独写了一篇 CodeSignal 会录屏吗？请在开始前读完，别等被标记了再看。第二，本页有意只讲 OA，我们对 Amazon 也是这样拆的，见 Amazon OA 指南。从电面开始的所有内容，都在上面链接的完整 Roblox 指南里。

接下来是不会过时的部分：无论哪个平台出题，我们题库里 Roblox OA 题目的内容都惊人地一致。本指南接下来就是教这些。

模拟题是 Roblox 的招牌

Roblox 真题 — Detect runs and collapse a numeric grid 给你一个 m×n 的数字网格。首先找出所有由三个或以上相同数字组成的横向或纵向连续段，按先行后列的顺序报告每一段的起始格和长度。然后删除属于任何连续段的所有格子，让每一列中剩下的数字向下掉落，并从顶部补充。

这就是一个微缩版的三消游戏引擎，申请游戏平台的人对此不该感到意外。这里没有任何算法上的深度，考的是你能否执行两阶段的修改而不破坏自己的状态。

大多数候选人栽在这里：一边扫描连续段，一边删除格子。同一个格子可能同时属于一个横向段和一个纵向段，所以在扫描过程中删除，会让第二个连续段再也检测不到。正确的做法是先标记再修改：第一遍把所有连续段的格子收集进一个集合，第二遍再删除并应用重力。重力本身就是每一列从底部开始走一个写指针，把留下的数字往下复制，然后填充剩余部分。

两个阶段的时间复杂度都是 O(mn)，标记集合的空间复杂度是 O(mn)。如果你发现自己想用更花哨的办法，请停下来；判题系统要的是干净的状态管理，每多一层抽象，就多一个容易出 off-by-one 错误的地方。

同一类型中较简单的题也出现在我们的 Roblox 题库里：Can the character reach the destination?（角色能否到达终点）是带障碍物的网格上的普通 BFS，四个方向，一个起点，一个终点。在 OA 里这是热身题，唯一会丢分的方式，是忘了在入队时就把格子标记为已访问，而不是在出队时。如果在出队时才标记，又没有在节点出队时跳过已访问格子的判断，重复节点会一层接一层地越积越多，在隐藏的大网格上即使算法"正确"也会超时。

输入写着 10^9，就去证明不变量

Roblox 真题 — Simulate robot path and detect boundedness 机器人从原点出发，面朝北，执行由 G（向前一步）、L 和 R（90° 转向）组成的指令字符串。执行完字符串后会重复执行，最多重复 10^9 次。返回执行一遍之后的位置和朝向，并判断如果字符串无限重复，轨迹是否始终保持在某个有界区域内。

(a) 部分是一个 10 行的模拟。(b) 部分才是真正的问题，约束里的 10^9 是判题系统在告诉你：模拟重复执行是跑不完的。

题目期望你找到的论证是：把字符串执行一遍，看两样东西，净位移 d 和最终朝向。如果 d 是 (0, 0)，机器人回到了起点，之后每一遍都沿同一个回路重走。如果 d 不为零但朝向改变了，那么经过两遍或四遍之后，旋转会合成回朝北，而每一遍的位移相对上一遍分别旋转 90°、180° 或 270°，最终相互抵消为零。只有当 d 不为零并且朝向仍然是北时，机器人才会沿直线一路走下去。

def is_bounded(s: str) -> bool:
    x = y = 0
    dx, dy = 0, 1              # facing north
    for c in s:
        if c == 'G':
            x, y = x + dx, y + dy
        elif c == 'L':
            dx, dy = -dy, dx   # rotate left 90°
        else:                  # 'R'
            dx, dy = dy, -dx   # rotate right 90°
    return (x, y) == (0, 0) or (dx, dy) != (0, 1)

时间复杂度 O(|s|)，空间复杂度 O(1)，与输入要求重复多少次无关。拿 "GL" 来推一遍：一遍结束在 (0, 1)，朝西；四遍走出一个正方形回到原点。有界，函数的结果也一致。

Roblox 在我们题库里还有一个更难缠的变体 Design robot path boundedness with repeats（带重复的机器人路径有界性），加入了障碍物，以及重复上一条指令的数字指令。先想清楚到底变了什么：障碍物破坏了干净的旋转论证，因为第一遍里被挡住的一步，在第二遍的地形里可能是通的。补救办法是状态重复。机器人的朝向最多每四遍就回到初始方向，所以在每一遍完整执行后记录 (位置, 朝向) 状态；只要某个状态重复出现，轨迹就形成循环，是有界的。这个论证有一个值得点明的漏洞：除非你能给出需要检查多少遍的上界，否则一直没看到重复什么也证明不了，所以你仍然欠一个终止性的论证。把这个漏洞主动说出来，恰恰是这道题想找的资深级信号。

窗口计数在每个岗位方向都会出现

Roblox 真题 — Implement recent-requests counter 为一个 Web 服务构建内存中的 hit counter：hit(timestamp) 记录一次请求，getHits(timestamp) 返回过去 5 分钟内有多少次请求。时间戳按非递减顺序到达，多个请求可能共用同一个时间戳。

这道题来自一位机器学习工程师的筛选，而软件工程师也报告过结构几乎相同的题，这说明 Roblox 会跨岗位复用窗口计数。它和他们的业务直接对应，每个游戏体验都需要请求跟踪和滥用限制。

干净的解法是一个存 (时间戳, 计数) 对的 deque，加上一个累计总数。在 getHits 时，只要队首时间戳小于或等于 timestamp - 300，就从队首淘汰：

from collections import deque

class HitCounter:
    def __init__(self):
        self.q = deque()       # [timestamp, count] pairs
        self.total = 0

    def hit(self, ts: int) -> None:
        if self.q and self.q[-1][0] == ts:
            self.q[-1][1] += 1
        else:
            self.q.append([ts, 1])
        self.total += 1

    def getHits(self, ts: int) -> int:
        while self.q and self.q[0][0] <= ts - 300:
            self.total -= self.q.popleft()[1]
        return self.total

每个时间戳只进出 deque 一次，所以两个操作的均摊复杂度都是 O(1)。空间与自上次查询以来的不同时间戳数量成正比，淘汰是惰性的，deque 只在 getHits 运行时才修剪，每次查询之后都会回落到窗口内的时间戳。隐藏测试的陷阱是淘汰边界：这里的"过去 5 分钟"指的是半开窗口 (ts − 300, ts]，所以恰好在 ts - 300 的请求已经出窗口。把 <= 写错，你就会挂在一个你永远看不到的测试上。

Roblox 真题 — Implement a sliding-window rate limiter 思路相同，但更狠：allow(userId, timestampMs) 必须保证每个用户在最近 W 毫秒内最多允许 N 个请求，并返回每个请求是否被放行。后续追问把限制扩展为按用户和游戏分别计算。

比 hit counter 多了两处升级。第一，状态变成了按用户划分的 deque 字典，而追问只是把字典的 key 换成 (userId, gameId) 对，所以请把代码写成 key 只是一个函数参数。第二，经典错误：被拒绝的请求不要记录。如果用户已超出限额，被拒的那次尝试不能占用名额，否则一个不停重试的客户端会把自己永远锁死。先淘汰，检查 len(dq) < N，然后才追加。

精确的滑动窗口对每个活跃 key 要花 O(N) 内存。追问讨论时值得说一句：在 Roblox 的规模下，你会改用固定窗口计数器或令牌桶，并接受边界上轻微的不精确，但 OA 的判题系统要的是精确版本。分清题目要的是哪一种，本身就是考察的一部分。

更新下的聚合：根据查询比例选择数据结构

Roblox 真题 — Track Highest-Earning Experience 你要处理一串针对游戏体验的操作：'U' 对某个命名的体验应用一次收益增量，'Q' 询问当前收益最高的体验。返回每次查询的答案。

陷阱就在显而易见的解法里。保存一个收益字典和一个滚动的 (best_name, best_value) 对，每次 'U' 都更新它，查询 O(1) 回答。在所有增量为正的样例上它都能通过。然后隐藏测试给当前的领先者一个负增量，你缓存的最大值就过期了，而且没有 O(1) 的办法找到第二名。题目里没有任何地方限制增量必须为正，可见样例又往往比较温和，所以请假设隐藏测试至少会让领先者掉下来一次。

有三种方案，哪一种合适取决于操作的比例：

lazy heap 要练到随手就能写出来。每次更新都压入一个新的 (−profit, name) 条目，从不删除；查询时，弹出那些记录的收益与字典不一致的条目，直到堆顶是最新的为止：

import heapq
from collections import defaultdict

profit = defaultdict(int)
heap = []                       # (-profit, name), possibly stale

def update(name: str, delta: int) -> None:
    profit[name] += delta
    heapq.heappush(heap, (-profit[name], name))

def query() -> tuple[str, int]:
    while True:
        p, name = heap[0]
        if -p == profit[name]:
            return name, -p
        heapq.heappop(heap)     # stale, discard

每个过期条目最多被弹出一次，所以 m 次操作的总工作量保持在 O(m log m)。如果面试官追问并列的情况，要明确定一个规则（比如字典序最小的名字），并把它编码进堆的键 (−profit, name) 里；Python 的元组排序会自动处理好。

日志题：先精确解析，再计数

Roblox 真题 — Find most frequent call stack from logs 一个单线程程序的日志记录了函数的进入和退出。重建随时间演变的调用栈，在每次进入之后把它快照成一个字符串，返回出现次数最多的快照及其次数。

偏基础设施风格的解析在 Roblox 的筛选里反复出现，这也符合一家工程师要花大量时间看游戏服务器遥测数据的公司。算法就是一个栈加一个 Counter，但得分靠的是精确：只在进入之后快照，绝不在退出之后快照；退出时弹栈，并且只在题目保证的范围内相信输入格式没问题。

有一个细节值得当面说出来：把栈拼接成字符串，每次进入要花 O(depth)，所以 n 个事件、最大深度 d 的整个过程是 O(n·d)。对 OA 来说够用了。如果追问在规模上加压，答案是对栈状态做增量哈希，让每次快照变成 O(1)，代价是要处理哈希冲突。另外，要选一个不可能出现在函数名中的分隔符，或者干脆用栈的元组而不是拼接后的字符串作为 Counter 的键；元组可以彻底避开歧义。

它更简单的同类题也在我们的 Roblox 题库里：Find the Most Frequent Log Call（找出现最频繁的日志调用）是一个单纯的频次统计，追问涉及并列、top-k（用堆可以做到 O(n log k)）以及流式处理。当 OA 里的一道题看起来这么简单时，可见的任务只是入场费，追问里的约束才是真正的题目。

隐藏测试决定你的分数，而追问会告诉你它们藏在哪

Roblox 真题 — Find largest digit-sum bucket size 对 [low, high] 中的每个整数，计算其数位和，并按数位和对数字分组。返回最大那一组的大小。题目给出的追问：当范围极其巨大时，你能不能避免逐个访问每个数字？

朴素循环的复杂度是 O((high − low) · digits)，空间很小，因为小于 10^10 的数的数位和都落到 1..90 之间。它能通过所有可见样例，因为可见样例用的范围都很小。追问那句话是判题系统在告诉你隐藏测试在哪里：范围大到枚举会超时。

扩展性的答案是数位 DP。定义 f(N, s) 为 [0, N] 中数位和为 s 的整数个数，通过遍历 N 的各位、在每个位置统计低于前缀的数字来计算；那么每个桶的大小是 f(high, s) − f(low − 1, s)，整体成本为 O(digits × 90 × 10)，实际上近似常数。你很少需要在 OA 里把完整的数位 DP 写出来。自动判分只看你的代码通过了多少，但花一分钟写一段注释勾勒扩展思路，只要之后有真人读这份报告，就是值得的。

这个模式可以推广，也是备考 Roblox OA 最有用的一个思路转变。到目前为止本文提到的每一种失败模式，都是隐藏测试失败：在出队时才标记已访问导致的 O(n²) BFS、hit counter 里的 <= 淘汰边界、让缓存最大值失效的负增量、模拟 10^9 次机器人重复。这些都不会在样例上挂。我们那篇深度文章 为什么解法会在隐藏测试用例上失败，以及如何调试里有系统的检查清单；简短的版本是，提交前逼问自己三件事：约束允许的最大输入、题目中窗口或范围定义里的每一个边界值，以及样例恰好满足的任何隐含假设（有序？为正？唯一？）。

数据科学家的 OA 是编程加统计

Roblox 真题 — Implement four DS coding tasks 一个 CodeSignal 风格的测评，可以选 Python 或 R，包含四个相互独立的任务。其中一个要求计算双侧双样本 z 检验所需的样本量：你要根据一个历史数组估计指标的标准差，再结合显著性水平、期望的检验功效和最小可检测效应。

如果你面的是数据科学方向，这场 OA 不是四道 LeetCode 题。它考的是需要你用可运行的代码表达出来的统计学。对于功效分析这个任务，每组样本量的公式是 n = 2σ²(z₁₋α/2 + z_power)² / Δ²，其中 σ 由历史观测值估计，结果向上取整。编程内容很简单；筛选的是你能不能在没有公式表的情况下，从 "alpha = 0.05, power = 0.8" 得到正确的 z 分位数（1.96 和 0.84）。

DS 题库里也有图论风格的题：Find maximum follow depth using recursion（用递归求最大关注深度）给你一张社交图里的关注边，要求你用 DFS 求从某个起始用户出发可达的最长关注链。写代码之前该说的话是：先问遇到环会怎样，因为 A 关注 B、B 又关注 A 会无限递归，而你是用 visited 集合来防护，还是题目已经排除了环，整个解法都会不同。不用人提醒就主动提出这一点，就是只会写代码的人和见过生产数据的数据科学家之间的区别。完整的 DS 面试流程，包括 OA 之后的分析案例轮，都在顶部链接的 Roblox 数据科学家面试指南里。

十天备考计划

这场 OA 不需要三个月。你需要的是针对上述模式、在时间压力下、用你实际会用的语言做的有针对性的重复练习。

第 1–2 天：模拟题的熟练度。 不计时地做上面章节里的网格塌陷题和机器人有界性题。目标是零状态破坏的 bug：先标记再修改，用不变量代替暴力。

第 3–4 天：窗口计数。 先做 hit counter，再做带按游戏扩展的限流器。两道都从空白编辑器重写两遍；第二次每道应该不到 15 分钟。

第 5–6 天：聚合与日志。 先用 lazy heap 做最高收益追踪器，再做调用栈计数器。练习边写边在注释里讲清取舍，因为有些平台会把你的代码展示给真人评审，我们的 技术面试评分标准拆解里有相关说明。

第 7–8 天：完整限时彩排。 四道题，70 分钟，如果你的正式测评有监考就开着摄像头。要模拟这种限制；节奏失控比知识缺失更常毁掉 OA，而只有在计时下的彩排才能修正节奏。

第 9–10 天：自己攻破自己的代码，然后休息。 拿出你彩排时的解法，试着像判题系统那样让它们挂掉：最大输入、边界时间戳、负值、单元素用例。然后收手：重读邀请邮件，确认监考规则，测试摄像头和网络。

OA 之后

典型的 OA 之后的流程：

回复时间因批次差异很大，分数处于边缘的候选人可能比任何一种结果都在审核中停留更久。第一周不要把沉默当成被拒；如果邀请里没有写明时间线，请向 recruiter 询问。

关于分数怎么用，有两点要知道。第一，像 CodeSignal 这样的平台交给公司的是逐题的报告，而不仅仅是通过与否；难题上拿到部分分，可能比交白卷更有分量，这会改变你在测评中途分配时间的方式。第二，OA 的高分不会带到 onsite。电面和 VO（线上 onsite）各轮考的是实时解题、沟通，以及（对资深岗位）系统设计，这些 OA 都没有考到。一旦通过，立即切换备考方向：开头链接的 Roblox 软件工程师面试指南涵盖了从电面开始的整个流程。

在 PracHub 上练习这些题

按每道题所训练的技能顺序，练习这些 Roblox 真题：

• 变更下的网格模拟 — Detect runs and collapse a numeric grid：两阶段的先标记再修改，不破坏状态。
• 用不变量推理代替暴力 — Simulate robot path and detect boundedness：把 10^9 次重复的约束变成两行证明。
• 滑动窗口状态 — Implement a sliding-window rate limiter：按 key 划分的 deque、淘汰边界，以及被拒请求的陷阱。
• 更新下的聚合 — Track Highest-Earning Experience：根据查询比例在重扫和 lazy heap 之间选择，并能应对负增量。
• 精确的日志解析 — Find most frequent call stack from logs：重建调用栈，得分点都在细节里。
• 概率推理 — Detect shuffle-mode sequence（判断是否为随机播放序列）：判断观察到的歌曲序列是否符合不重复的随机播放，是 Roblox 少见的推理多于敲代码的题。

完整的按公司标记的题库在 PracHub 题库，算法题集在 Coding & Algorithms 下，更多针对具体平台的指南在 资源里。

把 Roblox 真题变成一个学习闭环

上面汇总的 Roblox 真题，最好按顺序做，而不是当阅读清单看。每道题都用同样的四步循环，让练习产出你能据以调整的证据。

每道链接的题先做一遍求正确，再在一个不被打断的计时器下做一遍。第二遍时，至少改变一个约束或边界用例，而不是去背第一遍的实现。