← Back to blog Bloomberg VO High-Frequency Questions 2025-2026: Aggregated Stats from 60+ 1Point3Acres Debriefs
VO Bloomberg

Bloomberg VO High-Frequency Questions 2025-2026: Aggregated Stats from 60+ 1Point3Acres Debriefs

2026-05-18

Data source: monthly scrapes by the oavoservice team from the 1Point3Acres Bloomberg board plus offer-group debriefs, window Oct 2024 – May 2026, totaling 60+ VO writeups. This article doesn't repeat our 3-round playbook — it answers one concrete question: which Bloomberg VO problems actually keep recurring?

1. Sample Methodology

Dimension Value
Time window Oct 2024 – May 2026
Sample 60+ VO writeups
Roles SDE Intern, NG, L4-L5 lateral
Cities NYC (80%), London (10%), Shanghai (8%), Tokyo (2%)
Counting unit "Topic" — different wrappers of the same problem are merged

2. Top 10 Frequency Ranking

Rank Problem Hits Difficulty Round
1 Flatten Multilevel Linked List (LC 430) 18 Med R1
2 LRU Cache (LC 146) 15 Med R1
3 Word Break I / II (LC 139/140) 12 Med / Hard R2
4 Trie + Prefix variants 10 Med R2
5 Top K Frequent Elements / Words (LC 347/692) 9 Med R1
6 Calendar Busy / Merge Intervals (LC 56/57) 8 Med R2
7 CSV Folder Sum / nested aggregation 7 Med R2
8 Word Search Grid (LC 79) 6 Med R2
9 Bus Tracker / OOD design 5 Med R3
10 Wildcard Match (LC 44) 5 Hard R2

Takeaway: top 4 cover 55% of all hits — must-master tier. Items 6-10 are "guardrails": each appears <15% of the time, but unfamiliarity here causes one-shot failures.

3. Top 1: Flatten Multilevel Doubly Linked List

Variant: given a doubly linked list with child pointers, flatten it into a single level in DFS order.

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 None
    stack = [head]
    prev = None
    while stack:
        cur = stack.pop()
        if prev:
            prev.next = cur
            cur.prev = prev
        if cur.next:
            stack.append(cur.next)
        if cur.child:
            stack.append(cur.child)
            cur.child = None
        prev = cur
    return head

Time: O(n)　Space: O(d), where d is max child-nesting depth

BBG follow-ups: 1) without a stack? → recursion with a tail pointer; 2) cycle possibility? → visited-set guard.

4. Top 2: LRU Cache

Stem: implement LRU with O(1) get / put. Bloomberg has been asking this for 6 years; the follow-ups are what evolve.

class LRUCache:
    def __init__(self, capacity):
        self.cap = capacity
        self.cache = {}
        self.head = self.tail = None

    class _Node:
        __slots__ = ("key", "val", "prev", "next")
        def __init__(self, k, v):
            self.key, self.val = k, v
            self.prev = self.next = None

    def _add_front(self, node):
        node.prev = None
        node.next = self.head
        if self.head:
            self.head.prev = node
        self.head = node
        if not self.tail:
            self.tail = node

    def _remove(self, node):
        if node.prev:
            node.prev.next = node.next
        else:
            self.head = node.next
        if node.next:
            node.next.prev = node.prev
        else:
            self.tail = node.prev

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

    def put(self, key, value):
        if key in self.cache:
            node = self.cache[key]
            node.val = value
            self._remove(node)
            self._add_front(node)
            return
        if len(self.cache) >= self.cap:
            evict = self.tail
            self._remove(evict)
            del self.cache[evict.key]
        node = self._Node(key, value)
        self.cache[key] = node
        self._add_front(node)

Time: O(1) per op　Space: O(capacity)

BBG 2026 new follow-up: how to make it thread-safe? → threading.RLock or sharded locking.

5. Top 3: Word Break II (production version)

Stem: given string s and word dict, return all valid sentence segmentations.

from functools import lru_cache

def word_break(s, word_dict):
    words = set(word_dict)

    @lru_cache(maxsize=None)
    def helper(start):
        if start == len(s):
            return [""]
        out = []
        for end in range(start + 1, len(s) + 1):
            piece = s[start:end]
            if piece in words:
                for tail in helper(end):
                    out.append(piece if not tail else piece + " " + tail)
        return out

    return helper(0)

Time: worst O(2^n), avg O(n²·avg_len)　Space: O(n²)

BBG follow-ups: 1) infinite dict — how to prune? → Trie + DFS; 2) "can it be broken at all" — drop from O(2^n) to O(n²)? → 1D DP.

6. Top 5 Behavioral Questions

  1. Why Bloomberg? (asked ~80%)
  2. How do you handle disagreement with peers / PMs?
  3. The project you're proudest of — how was the impact quantified?
  4. A time you received critical feedback — what was the takeaway?
  5. How do you keep up with finance / tech changes? (BBG-specific)

BBG culture keywords: Customer Obsession, Tinker Mentality, Curiosity. One concrete story + numeric outcome per keyword.

7. Top 5 Pitfalls Reported on 1Point3Acres

  1. Drilled LC, ignored OOD — BBG R3 always has OOD; pure-LC people fall apart in round 3
  2. Over-optimizing into TLE — BBG gives 60min for 1-2 problems; correct first, then optimize
  3. Ignored edge cases — empty list, self-pointing child, etc. — list them aloud
  4. Only practiced BQ in textbook English — NYC interviewers are diverse; acclimate to accents by listening to recordings
  5. Skipped clarification — vague stems must be questioned; BBG values "asking the right question"

8. FAQ

Q1: How does BBG VO compare with Meta / Google?

A: Algorithm depth ≈ Meta E4 / Google L4, but OOD weight is higher than at Meta / Google. Onsite pass rate ~30%.

Q2: How fast does the BBG question pool refresh on 1Point3Acres?

A: Weekly — roughly 3–5 fresh debriefs per week. Our pipeline pulls daily; the BBG core pool stabilized to ~20 rotating problems in 2026.

Q3: Does Bloomberg run an OA?

A: NG usually skips OA and goes straight to phone screen; some intern roles run a 30-min 2-question HackerRank screen.

Q4: Does BBG sponsor H1B?

A: Yes; NYC is the hub — London / Tokyo team-by-team. BBG H1B-friendliness > Citadel / Two Sigma.

Q5: Strong onsite but rejected — what now?

A: BBG sometimes ships detailed feedback (rare); ping the recruiter politely to ask. Re-apply after 6 months.

Q6: How long should BBG prep take?

A: In-role lateral: 6–8 weeks; NG full-time prep: 4 weeks. Concentrate on the top 4 problems (55% of hits) + OOD.

9. Need Bloomberg VO Help?

Bloomberg's three-round mix — algorithms + OOD + behavioral — has a unique difficulty profile: medium LC fluency plus rapid translation of requirements into class designs. If you're prepping:

We offer: this-week BBG hot questions, OOD mocks (Bus Tracker / Calendar / Trade Match), behavioral STAR coaching, and same-day live interview support.

Contact

Email: [email protected]
Telegram: @OAVOProxy
WeChat: Coding0201

Last updated: 2026-05-18　|　Author: oavoservice interview team