← 返回博客列表
OA ByteDance

ByteDance 字节跳动 OA 四题全AC复盘：区间判断 + 元音翻转 + 电池调度 + 链式遍历

2026-03-18

ByteDance OA 四题全AC复盘

ByteDance 字节跳动 OA 四题全AC复盘

早上刚做完一场字节跳动 OA，和 TikTok 一样在 CodeSignal 平台，70分钟 4 道题，做了十几场了，约 15 分钟搞定，全部都是从题库抽题。以下是完整思路与代码复盘。

考试概况

项目 详情
平台 CodeSignal
时长 70 分钟
题数 4 道
难度 Easy ~ Medium
岗位 Intern / New Grad SDE
结果 全AC，约 15 分钟

T1：区间判断（Interval Lookup）

题目思路

给你一个初始值，还有一个数组，初始值对数组求和以后，看值落在哪个区间里面，返回对应字符串。

解题方法

典型的 if-else 区间判断，或者用前缀和 + 二分查找。

def interval_lookup(initial: int, arr: list, intervals: list, labels: list) -> str:
    """
    initial: 初始值
    arr: 数组，对其求和后加到 initial
    intervals: 区间列表，如 [(0,10), (10,20), (20,100)]
    labels: 对应每个区间的字符串标签
    """
    total = initial + sum(arr)
    
    for i, (lo, hi) in enumerate(intervals):
        if lo <= total < hi:
            return labels[i]
    
    return labels[-1]  # 兜底

# 示例
print(interval_lookup(5, [3, 2, 1], [(0,5),(5,10),(10,20)], ["low","mid","high"]))
# total=11, 落在 (10,20) → "high"

时间复杂度：O(n + k)，n 为数组长度，k 为区间数
空间复杂度：O(1)

关键点

T2：元音单词翻转（Vowel Word Flip）

题目思路

把首尾都是元音字母的单词处理一下，它们中间翻转，首尾不变。

解题方法

先把 aeiouAEIOU 存成 set，遍历所有字符串，判断 s[0] 和 s[-1] 是否都在这个 set 里，是的话按题目意思翻转中间部分。

def vowel_word_flip(words: list) -> list:
    vowels = set('aeiouAEIOU')
    result = []
    
    for word in words:
        if len(word) >= 2 and word[0] in vowels and word[-1] in vowels:
            # 首尾不变，翻转中间
            middle = word[1:-1][::-1]
            result.append(word[0] + middle + word[-1])
        else:
            result.append(word)
    
    return result

# 示例
print(vowel_word_flip(["apple", "hello", "abcde", "orange"]))
# apple: a...e 首尾都是元音 → a + "lpp"[::-1] + e = a + ppl + e = "apple"
# abcde: a...e 首尾都是元音 → a + "bcd"[::-1] + e = a + dcb + e = "adcbe"

时间复杂度：O(n · m)，n 为单词数，m 为平均单词长度
空间复杂度：O(n · m)

关键点

T3：电池调度模拟（Battery Scheduler）

题目思路

你要用手机 t 分钟，手上有 n 块电池，每个电池的容量和充电速度不一样，你要轮着用，没电了就充，问最少需要多少块满电的电池。

模拟这个过程：按顺序用电池，记录每块电池什么时候能充满，然后每次换电池的时候找当前已经充满的，如果有多块按顺序找下一块，时间不够就 GG 了。

解题方法

import heapq

def min_batteries(t: int, capacity: list, charge_rate: list) -> int:
    """
    t: 需要使用手机的总分钟数
    capacity: 每块电池的容量（满电时可用时长）
    charge_rate: 每块电池每分钟充电量（容量单位/分钟）
    返回：最少需要的满电电池数，若不可能返回 -1
    """
    n = len(capacity)
    # ready_heap: (可用时间, 电池index) 已充满可用的电池
    # charging: (充满时间, 电池index) 正在充电的电池
    
    ready = [(0, i) for i in range(n)]  # 初始都满电，时间0可用
    heapq.heapify(ready)
    charging = []  # min-heap by ready_time
    
    current_time = 0
    batteries_used = 0
    
    while current_time < t:
        # 把已充满的电池移入 ready
        while charging and charging[0][0] <= current_time:
            ready_time, idx = heapq.heappop(charging)
            heapq.heappush(ready, (ready_time, idx))
        
        if not ready:
            return -1  # 没有可用电池
        
        _, idx = heapq.heappop(ready)
        batteries_used += 1
        use_until = current_time + capacity[idx]
        
        if use_until >= t:
            return batteries_used  # 这块电池能撑到结束
        
        # 开始充电：用完后立即充电
        charge_time = use_until + capacity[idx] / charge_rate[idx]
        heapq.heappush(charging, (charge_time, idx))
        current_time = use_until
    
    return batteries_used

时间复杂度：O(k log n)，k 为换电池次数
空间复杂度：O(n)

关键点

T4：链式遍历输出（Chain Traversal）

题目思路

给你一条链，让你输出以任意端点开始，遍历完整条链的访问顺序。

直接先把图存下来，然后维护一个当前节点，还有前驱节点，由于只是一条链，就不用 DFS/BFS 了，直接 while 循环模拟。

解题方法

from collections import defaultdict

def chain_traversal(n: int, edges: list) -> list:
    """
    n: 节点数 (1-indexed)
    edges: [(u, v), ...] 无向边，构成一条链
    返回：从某个端点出发遍历整条链的节点顺序
    """
    # 建邻接表
    adj = defaultdict(list)
    for u, v in edges:
        adj[u].append(v)
        adj[v].append(u)
    
    # 找端点（度为 1 的节点）
    start = None
    for node in range(1, n + 1):
        if len(adj[node]) == 1:
            start = node
            break
    
    # 特判：只有一个节点
    if start is None:
        return [1]
    
    # while 循环模拟链式遍历
    path = [start]
    prev = None
    curr = start
    
    while True:
        # 找下一个节点（不是前驱）
        nxt = None
        for nb in adj[curr]:
            if nb != prev:
                nxt = nb
                break
        
        if nxt is None:
            break  # 到达另一端点，结束
        
        path.append(nxt)
        prev = curr
        curr = nxt
    
    return path

# 示例：链 1-2-3-4-5
print(chain_traversal(5, [(1,2),(2,3),(3,4),(4,5)]))
# 输出: [1, 2, 3, 4, 5]

时间复杂度：O(n)
空间复杂度：O(n)

关键点

四题复杂度汇总

题目 算法 时间复杂度 空间复杂度
T1 区间判断 if-else / 前缀和 O(n + k) O(1)
T2 元音翻转 set + 字符串切片 O(n·m) O(n·m)
T3 电池调度 贪心模拟 + 堆 O(k log n) O(n)
T4 链式遍历 邻接表 + while O(n) O(n)

常见陷阱

题目 陷阱 解法
T1 区间端点开闭不清晰 仔细读题，确认是 < 还是 <=
T2 单字符单词边界处理 len >= 2 特判，或 word[0] == word[-1] 时注意不要翻转
T3 充电时间单位混用 统一用分钟，充满时间 = 用完时刻 + 容量/充电速率
T4 误用 visited 导致死循环 链上只需记录前驱 prev，无需完整 visited set

CodeSignal OA 应试技巧

TikTok / ByteDance OA 特点

临场策略

  1. 先扫一遍4题，判断难度分布，从最简单的开始
  2. T1/T2 通常 5 分钟内可解，先拿满分
  3. T3/T4 需要模拟，注意边界条件，留 20 分钟
  4. 写完先跑示例，再提交——CodeSignal 有隐藏测试用例
  5. 时间够的话，review 一遍 edge case（空数组、单节点、t=0 等）

相关 LeetCode 练习

题号 题目 对应 TikTok OA 题型
1893 Check if Range is Covered T1 区间判断
557 Reverse Words in String III T2 字符串翻转
1642 Furthest Building You Can Reach T3 贪心 + 堆
1971 Find if Path Exists in Graph T4 图遍历

🚀 需要 TikTok / ByteDance OA 辅助？

oavoservice 专注北美大厂 OA/VO 全程辅助，TikTok / ByteDance OA 是我们的高频服务场景，题库覆盖率极高。

立即添加微信：Coding0201

获取：

📱 微信：Coding0201 | 💬 Telegram：@OAVOProxy | 📧 [email protected]