DEV Community: oavoservice-cs

Meta University 实习 VO辅助真题分享

oavoservice-cs — Thu, 04 Jun 2026 10:08:05 +0000

Meta 的实习 VO 题目不偏怪，但几乎每道题都有一个 Follow-up，逼你把暴力解优化到最优、或在限制条件下重写。这篇复盘两道真实风格的 VO 题——一道字符串子序列计数，一道原地找重复——再附上 Meta 实习的 12 周时间线，让你知道哪几周才真正决定 return offer。

VO 1：统计 words 中是 s 子序列的个数
给一个主串 s 和一个字符串数组 words，统计 words 里有多少个是 s 的子序列。

示例：s = "abc", words = ["a", "bb", "acd", "ace"] → 输出 2（"a" 和 "ace" 是子序列）

基础解法：双指针
对每个 word 用双指针扫一遍：当前字符匹配则两个指针都走，否则只走主串指针。word 指针走到底说明它是子序列。

def is_subsequence(word, s):
i = 0 # word 指针
for ch in s:
if i < len(word) and word[i] == ch:
i += 1
return i == len(word)

def count_subsequences(s, words):
return sum(is_subsequence(w, s) for w in words)
复杂度：O(m · n)，m = 所有 word 总长，n = len(s)。

Follow-up：words 很多、s 很长，如何优化？
优化思路：预处理主串 s，建一个 charIndex——记录每个字符在 s 中出现的所有位置（升序）。对每个 word 的字符，用二分查找在「上一个匹配位置之后」快速定位下一个出现点。

from bisect import bisect_right
from collections import defaultdict

def build_index(s):
idx = defaultdict(list)
for i, ch in enumerate(s):
idx[ch].append(i)
return idx

def is_subseq_fast(word, idx):
prev = -1 # 上一个匹配到的位置
for ch in word:
positions = idx.get(ch)
if not positions:
return False
# 找第一个 > prev 的位置
j = bisect_right(positions, prev)
if j == len(positions):
return False
prev = positions[j]
return True

def count_subsequences_fast(s, words):
idx = build_index(s)
return sum(is_subseq_fast(w, idx) for w in words)
复杂度：预处理 O(n)，每个 word 用二分 O(k · log n)，k = word 平均长度。总计 O(n + m · k · log n)——当 words 很多时远优于暴力。

口述要点：先讲双指针 baseline，再说「主串固定、要查很多次 → 预处理 + 二分」这个优化动机，面试官最看重这个推导过程。

VO 2：原地找数组中所有重复元素
长度为 n 的数组 array，每个元素 x 满足 0 ≤ x ≤ n-1。找出数组中所有重复的元素。

示例：input = [3, 1, 2, 3, 0] → output = [3] Follow-up：不用额外空间、不用递归或函数调用。

核心思路：原地交换归位
每个元素 x 应该待在下标 x 的位置。遍历数组，把当前元素交换到它该在的位置；如果目标位置已经是正确的值，说明遇到了重复。

def find_duplicates(array):
n = len(array)
res = []
i = 0
while i < n:
x = array[i]
# x 应该待在下标 x
if array[i] != i:
if array[array[i]] == array[i]:
# 目标位置已是正确值 → 重复
if array[i] not in res:
res.append(array[i])
i += 1
else:
# 交换归位
array[array[i]], array[i] = array[i], array[array[i]]
else:
i += 1
return res
复杂度：时间 O(n)，空间 O(1)。关键：每次交换都把一个元素放到正确位置，所以总交换次数是 O(n)——while 循环不会退化成 O(n²)。

Follow-up 满足点：没用额外空间（原地交换）、没用递归、没用额外函数调用——完全符合限制。

Meta 实习时间线：哪几周决定 return offer
很多人不知道，Meta 实习的评估其实只看前 10 周。以 12 周实习为例：

周次阶段说明
Week 1-3 Onboarding（入职）熟悉环境、配 mentor、上手第一个任务
Week 5-6 Mid-cycle review 中期反馈，决定后半程方向
Week 10-11 Final 决策 return offer 在这里定
Week 11-12 收尾放松评估已结束，享受最后两周
核心提醒：只有 Week 1-10 的表现会计入实习考核。所以前期就要主动定义清楚项目 scope、和 mentor 高频对齐、Week 5-6 的中期 review 一定要拿到明确反馈并据此调整。

备考建议
每道题都准备 Follow-up：Meta 几乎必追问优化或加限制，baseline 之后立刻能讲优化方向。
原地操作要练熟：交换归位、快慢指针、位运算标记，这类 O(1) 空间技巧高频出现。
边写边讲推导：面试官给的是「思路分」，不是「AC 分」——讲清楚为什么这样优化比直接写出最优解更重要。
沟通即评分：Meta 看重 communication，卡住时主动说出当前思路，往往能拿到提示。
FAQ
Q1：Meta University 和普通实习 VO 区别大吗？题型接近，都是「Medium + Follow-up」。Meta University 更偏基础数据结构 + 双指针 / 数组操作。

Q2：VO 几轮？实习通常 1~2 轮 coding VO（每轮 2 题），外加 behavioral。

Q3：可以用 Python 吗？可以。Meta 不限语言，Python 写双指针 / 原地交换很简洁，适合讲思路。

Q4：前期表现一般，后面还能翻盘吗？能，但要趁早。Week 5-6 的 mid-cycle review 是关键纠偏点，拿到反馈后立刻调整还来得及。

正在准备 Meta 实习 VO？

如果你 baseline 能写但 Follow-up 卡壳、原地操作不熟、或想要面试日真人同步陪跑做实时 cue，可以聊聊看完整方案：高频题型精讲 + 限时 mock + vo辅助 + 逐题复盘。

Duolingo AI Research Engineer Virtual Onsite Real Interview case share

oavoservice-cs — Thu, 04 Jun 2026 10:06:10 +0000

Behind Duolingo's language-learning product sits an engine driven by learning science plus machine learning: which question to surface, how soon a user will forget, and how to retain memory with the least practice are all decided by models. The AI Research Engineer role lives between Research Scientist and ML Engineer—you must read papers and design experiments, yet also turn models into shippable production code.

This track's virtual onsite is nothing like a standard SDE loop: coding is only one round, while the other three test ML depth, research-design intuition, and the systems skill to embed a model in the product. This article lays out the four-round VO skeletons, the high-frequency follow-ups, and a prep path, based on real feedback from this track.

Duolingo AI Research Engineer VO Overview
Dimension Details
Rounds 4 VO rounds (coding / ML depth / research design / applied system)
Per round 45-60 minutes
Platform Video + shared editor (CoderPad-style for coding)
Language Primarily Python; whiteboard derivations in the ML round
Focus Engineering + modeling depth + experiment thinking + product delivery
Flow Recruiter → tech phone screen → four VO rounds → team match
Key insight: the most common failure on this track is not the algorithm, but "can explain the paper yet writes messy code" or "can call the library yet cannot justify the modeling choice." Each round has a distinct focus, and a clear weakness in any single round can be a veto.
Round 1: Coding Implementation (Sequence Sampling)
Problem Statement
Given a vocabulary of length n where each word has weight weightsi, implement a sampler that draws k distinct words without replacement, proportional to the weights in expectation. After one build, it must support efficient repeated sampling.

Approach
The classic without-replacement weighted sampling is A-Res (exponential jump key): generate key = u^(1/w) for each element (u uniform in (0,1)) and keep the top-k keys. This is equivalent to a weighted top-k, doable in a single O(n) scan with a heap.

Python Solution
import heapq
import random

class WeightedSampler:
def init(self, weights):
self.weights = weights

def sample(self, k):
    # A-Res: key = u^(1/w), keep the largest k
    heap = []  # current top-k (key, idx)
    for i, w in enumerate(self.weights):
        if w <= 0:
            continue
        u = random.random()
        key = u ** (1.0 / w)
        if len(heap) < k:
            heapq.heappush(heap, (key, i))
        elif key > heap[0][0]:
            heapq.heapreplace(heap, (key, i))
    return [i for _, i in heap]

Time complexity: O(n log k) Space complexity: O(k) Follow-up: What if weights update dynamically? Answer: a Fenwick tree over prefix sums plus binary-search locate, giving O(log n) per update/sample.

Round 2: ML Depth (Spaced-Repetition Modeling) Scenario Duolingo's core is an SRS (Spaced Repetition System): predict the probability a user still recalls a word after interval t, to decide the next review time. The interviewer asks you to design this "memory model" from scratch.

Modeling Approach
The classic baseline is Half-Life Regression: model memory decay as an exponential

$$p = 2^{-t / h}, \quad h = \exp(\theta \cdot x)$$

where h is the half-life produced by a linear layer over features x (past correct count, error count, word difficulty, etc.), guaranteed positive. The loss fits both the recall probability p and the half-life h.

import numpy as np

def hlr_loss(theta, X, t, recalled, alpha=0.01):
# X: (N, d) features; t: (N,) intervals; recalled: (N,) 0/1
h = np.exp(X @ theta) # half-life, always positive
p = np.power(2.0, -t / h) # predicted recall probability
p = np.clip(p, 1e-6, 1 - 1e-6)
# main loss: squared error on recall probability + L2
loss = np.mean((p - recalled) ** 2) + alpha * np.sum(theta ** 2)
return loss
Why not a plain classifier: the interviewer wants to hear that you understand the half-life h is an interpretable quantity that directly drives scheduling—a black-box classifier cannot output "how long until the next review."

High-frequency follow-ups:

Cold start (new user/new word)? → Start with word-level priors plus a population mean.
How to evaluate? → Not accuracy, but calibration of recall probability plus MAE on p.

Round 3: Research Design and Experiments (A/B + Causal) Scenario "We want to verify whether shipping a new review-scheduling algorithm improves 7-day retention (D7). Design an experiment."

Breakdown Framework
Metrics: primary is D7 retention; guardrails are daily lessons and review load (avoid buying retention by piling on practice).
Unit and assignment: randomize by user (not session, to avoid contamination); run an A/A test before bucketing.
Sample size: back out N per arm from baseline retention and the minimum detectable effect (MDE), fixing power=0.8, α=0.05.
Novelty effect: scheduling changes carry a novelty effect—observe for ≥2 weeks rather than judging day one.
Causal trap: retention is a survivorship-bias minefield—looking only at active users overstates the effect; use intention-to-treat (ITT) from the assignment point.
from math import sqrt

def required_n_per_arm(p0, mde, z_alpha=1.96, z_beta=0.84):
# two-proportion test approximate sample size
p1 = p0 + mde
p_bar = (p0 + p1) / 2
num = (z_alpha * sqrt(2 * p_bar * (1 - p_bar))
+ z_beta * sqrt(p0 * (1 - p0) + p1 * (1 - p1))) ** 2
return num / (mde ** 2)

baseline D7=40%, want to detect +2 percentage points

print(int(required_n_per_arm(0.40, 0.02)))
What the interviewer is really watching: whether you proactively raise guardrail metrics and the novelty effect—just computing sample size is not enough.

Round 4: Applied System Design (Online Inference Pipeline) Scenario "Deploy the memory model above as a live service: when each user opens the app, return the 20 words to review today within 50ms. Tens of millions of daily actives."

Design Points
Layer Approach Rationale
Features Offline batch + light online features Precompute historical stats offline; assemble only real-time features per request
Model serving Light model (linear/small tree), vectorized batching A 50ms SLA forbids a heavy model scoring word by word
Scheduling Maintain each word's "next due time"; only due words enter the candidate pool Turn "prediction" into "priority-queue top-k"
Storage User-word state in a KV store (half-life, last review time) Reads/writes are per-user, naturally sharded
Offline feedback Nightly retrain on the day's feedback and update half-lives Closed loop: review result → update h → influences tomorrow's schedule
Core trade-off: push heavy computation offline and let the online path only "fetch due words + lightly rank," so it can sustain 50ms across tens of millions of daily actives.

Four-Round Prep Checklist Round Focus Resources Coding Weighted sampling, streaming top-k, reservoir sampling LeetCode + probabilistic algorithms ML depth Memory models, calibration, cold start, interpretability Duolingo HLR paper + recommender course Research design Full A/B workflow, guardrails, novelty, ITT Trustworthy Online Experiments System Online inference, feature pipeline, scheduling queue ML system design material

Preparing for the Duolingo AI Research Engineer virtual onsite?

Each of the four rounds probes a different weak spot; the hard part is not one problem but keeping all four dimensions—coding, modeling, experiments, systems—from collapsing. If you want batch-specific VO question reconstructions, focused drilling on memory models and experiment design, or VO assistance / VO proxy real-time pacing support, reach out. Send a screenshot of the job description, and we will break down the rounds first, then build a practice plan.

Add WeChat Coding0201 now to get Duolingo VO real questions and four-round drilling.

Contact
WeChat: Coding0201
Email: catcstech@gmail.com
Telegram: @OAVOProxy

DEV Community: oavoservice-cs

Meta University 实习 VO辅助 真题分享

Duolingo AI Research Engineer Virtual Onsite Real Interview case share

baseline D7=40%, want to detect +2 percentage points

Meta University 实习 VO辅助真题分享