Bloomberg 2026 NG SDE 校招两轮面经｜Valid Triangle + Flatten Multi-level Linked List 全程拆解

Bloomberg 在 2026 校招中的节奏是所有传统 IB / 金融 Tech 里最快的：9 月 23 日投递，当天就收到 HR 面试邀约，9 月 30 日校招组确认，10 月 2-3 日两天连面——onsite 两轮技术 + 行为，整套流程一周内走完。题目都是 LeetCode Medium 量级，但面试官的追问极度细节：smart pointer 怎么用、scoped vs unique 差别在哪、recurse 还是 stack 哪个更省内存。本文复盘一位 2026 鲜活通过候选人的两轮 onsite，每个环节都给出题目、考察点、答题模板。

Bloomberg 2026 NG SDE 校招时间线

日期	阶段
9.23	通过学校 career portal 投递简历
9.23	HR 当日发邀约（含校招 onsite 日期选项）
9.30	校招组确认面试时间
10.2	第一轮 onsite（技术 + BQ）
10.3	第二轮 onsite（resume deep dive + 技术追问）
10.10 内	offer call

第一轮 onsite：BQ + Coding 双题

1.1 行为题模板（25 分钟）

第一轮面试官是华人 senior engineer，气氛非常放松。BQ 部分按以下顺序：

1. Self-introduction（3 分钟）：教育背景 + 一个最自豪的项目
2. 最有代表性的项目经历：选与 Bloomberg 业务最相关的——金融、终端、实时数据
3. 最具挑战性的项目：重点讲模糊需求 + 沟通过程——Bloomberg 极度看重 ambiguous requirements 的处理
4. 追问：
   • "你怎么跟团队 align 需求？"
   • "最终结果是否符合预期？"
   • "如果再来一次你会怎么改进？"

BQ 答题密码：Bloomberg 的 BQ 评分倾向"沟通颗粒度"——把每个抉择背后的选项 + 取舍讲清楚。建议每个 STAR 故事内置至少 1 个"trade-off"动作。

1.2 Coding 题 1：Valid Triangle Number（LeetCode 611）

题目：给定整数数组 nums，返回可以构成有效三角形的三元组数量（任意两边和大于第三边）。

Bloomberg 期望解法：排序 + 双指针 O(n²)

from typing import List

def triangle_number(nums: List[int]) -> int:
    nums.sort()
    n = len(nums)
    count = 0
    for k in range(n - 1, 1, -1):
        i, j = 0, k - 1
        while i < j:
            if nums[i] + nums[j] > nums[k]:
                count += j - i
                j -= 1
            else:
                i += 1
    return count

时间复杂度：O(n²)
空间复杂度：O(1)（如果允许原地排序）

面试官追问：

• "为什么 k 从大到小？" → 固定最长边，便于双指针在前缀里找两条短边
• "为什么 count += j - i？" → 因为对当前 j 满足条件，则 i+1, i+2, ..., j-1 同样满足
• "排序后还能不能优化？" → 这题 O(n²) 已经是 lower bound

1.3 Coding 题 2：Flatten a Multi-level Linked List（LeetCode 430）

题目：双向链表节点有 next 和 child 指针，将其展开为单层链表。

Bloomberg 期望解法：栈模拟 / 递归 DFS

class Node:
    def __init__(self, val, prev=None, next=None, child=None):
        self.val = val
        self.prev = prev
        self.next = next
        self.child = child

def flatten(head):
    if not head:
        return head
    stack = []
    curr = head
    while curr:
        if curr.child:
            if curr.next:
                stack.append(curr.next)
            curr.next = curr.child
            curr.child.prev = curr
            curr.child = None
        if not curr.next and stack:
            nxt = stack.pop()
            curr.next = nxt
            nxt.prev = curr
        curr = curr.next
    return head

时间复杂度：O(n)，n 为所有节点总数
空间复杂度：O(d)，d 为最大嵌套层数

面试官追问：

• "用 stack 和 recurse 哪个更省内存？" → 都是 O(d)，但 stack 更可控（避免 Python recursion limit）
• "如果改成有 cycle 的输入怎么办？" → 用 visited set 检测
• "如果链表节点不带 prev 指针呢？" → 同样的逻辑去掉 prev 维护即可

第二轮 onsite：Resume Deep Dive + 技术追问

第二轮有两位面试官：一位印度口音 ABC、一位美国本土 engineer。风格更"resume 导向"：

2.1 Resume 项目复盘（30 分钟）

典型开场：

"If you were to redo your most recent project, how would you improve it?"

评分点：

• 至少 2 个具体的"如果再来一次"改进点
• 每个改进点带数据支撑（性能提升 %、成本降低）
• 提到 trade-off——为什么当初没这么做

Bloomberg 这一轮最常追问的技术细节：

1. C++ smart pointer："你提到 unique_ptr，那 shared_ptr 何时用？scoped_ptr 跟 unique_ptr 的差别？"
2. 并发："如果你这个服务要支撑 100k QPS，你会怎么改？"
3. 测试："你的 test 覆盖率多少？mock 了哪些依赖？"

2.2 Coding 题：LRU Cache 设计

题目：实现 LRU Cache，get 和 put 都 O(1)。

Bloomberg 期望解法：双向链表 + Hash Map

class DLLNode:
    __slots__ = ("key", "val", "prev", "next")
    def __init__(self, key=0, val=0):
        self.key = key
        self.val = val
        self.prev = None
        self.next = None

class LRUCache:
    def __init__(self, capacity: int):
        self.cap = capacity
        self.cache: dict = {}
        self.head = DLLNode()
        self.tail = DLLNode()
        self.head.next = self.tail
        self.tail.prev = self.head

    def _remove(self, node):
        node.prev.next = node.next
        node.next.prev = node.prev

    def _add_to_front(self, node):
        node.prev = self.head
        node.next = self.head.next
        self.head.next.prev = node
        self.head.next = node

    def get(self, key):
        if key not in self.cache:
            return -1
        node = self.cache[key]
        self._remove(node)
        self._add_to_front(node)
        return node.val

    def put(self, key, val):
        if key in self.cache:
            self._remove(self.cache[key])
        node = DLLNode(key, val)
        self.cache[key] = node
        self._add_to_front(node)
        if len(self.cache) > self.cap:
            lru = self.tail.prev
            self._remove(lru)
            del self.cache[lru.key]

Bloomberg 这道题的追问深度：

• "为什么不用 OrderedDict？" → 答：实战时手写双链表更能展示数据结构理解
• "如果 capacity = 0 怎么办？" → 必须显式处理，否则 put 一定失败
• "如果要支持 TTL 怎么改？" → 在 node 上加 expire_at，get 时检查

Bloomberg 校招的 5 个评分维度

维度	占比	典型表现
Coding 正确性	30%	Medium 一次 AC + 边界处理
沟通清晰度	25%	出题前先 clarify 输入输出 + 边界
技术深度	20%	smart pointer、concurrency 都能展开
BQ + 文化契合	15%	ambiguous requirement 处理 + 团队协作
学习速度	10%	追问新知识时能现场推理

Bloomberg vs Citadel / JPMorgan 校招对比

维度	Bloomberg	Citadel	JPMorgan
Onsite 轮数	2	3-4	3
OA 是否必经	否（部分免 OA）	是	是
算法难度	LeetCode Medium	LeetCode Medium-Hard	LeetCode Medium
BQ 占比	30%	10%	50%
平均时间线	OA 到 offer 2-3 周	3-5 周	4-8 周

FAQ

Bloomberg NG SDE 校招通过率高吗？

校招通过率约 12-18%（投递 → offer）。进入 onsite 后约 30-40% 拿 offer，所以 onsite 表现是分水岭。本案例两轮 onsite 间隔 1 天，节奏非常紧凑，强调"快速 context switch"能力。

Bloomberg 算法考点重不重？

中等。LeetCode Medium 节奏 + 60% Bloomberg 高频题已经够用。重点关注：linked list 变体、双指针、tree 遍历、LRU 设计。Bloomberg 出题非常"教科书风格"，几乎不出 trick 题。

Onsite 间隔只有 1 天能拒绝吗？

可以与 HR 协商。但 Bloomberg 校招组的快节奏文化决定了早面早 offer，如果时间允许建议接受连面。

Bloomberg BQ 怎么准备？

重点准备 5 个 STAR 故事，覆盖：模糊需求 + 团队协作 + 失败复盘 + 领导力 + 跨文化沟通。Bloomberg 比较在意细节追问，每个故事要有至少 3 个 follow-up 答案备好。

Bloomberg 内推有用吗？

非常有用。Bloomberg HR 对内推简历的响应率约 2x，且校招会优先 schedule 内推候选人。如果有 Bloomberg 在职员工内推，HR 1-2 个工作日内必回。

---

正在准备 Bloomberg NG SDE 校招？

oavoservice 提供 Bloomberg / Citadel / JPMorgan 等金融科技公司的 onsite 全流程辅助：BQ 故事打磨、coding 一对一 mock、resume deep dive 模拟问答。我们的导师包括前 Bloomberg engineer，对 Bloomberg 的"细节追问"风格有完整应对手册。

立即添加微信：Coding0201，获取 Bloomberg 校招辅导。

#Bloomberg #BloombergVO #NewGrad #SDE #金融校招 #面经

---

联系方式

Email: [email protected]
Telegram: @OAVOProxy