← Back to blog Bloomberg Intern First Round: Verbal Reasoning
VO Bloomberg

Bloomberg Intern First Round: Verbal Reasoning

2026-07-16

Bloomberg's software intern first round is known for being a "talk while you code" exercise: what gets graded is not whether your code runs, but whether you can explain your thinking clearly, decompose the problem cleanly, and stay in sync with the interviewer. The round runs 60 minutes and splits into three stages — a project chat, two HackerRank algorithm problems, then a few minutes of your questions. This article recaps the full round from real debriefs, gives complete Python solutions with complexity analysis for both problems, and adds a practical VO support / VO proxy prep path.

First-Round Overview

Item Detail
Platform HackerRank (no screen share required)
Total length About 60 minutes
Stages Intro + project Q&A (10 min) -> two algorithm problems (45 min) -> your questions (a few min)
Time per problem About 20 minutes each
Difficulty Low-to-medium (LC Easy-Medium range)
Core focus Verbal reasoning, problem decomposition, complexity analysis, communication
Run code required No — explain the approach first, then code

Stage 1: Intro + Project Q&A (~10 minutes)

The interviewer opens by asking you to pick a "most interesting project" and walk through it. The questions are templated and won't dig deep into technical internals. They usually cover:

You rarely fail here; the goal is to give the interviewer a quick, positive read on you. Polish one project into a 2-minute spoken version: one-line context -> your role -> one concrete technical challenge -> outcome and reflection, and avoid a play-by-play narration.

Stage 2: Two HackerRank Problems (~45 minutes)

This is the stage that decides the outcome. Both problems are done on HackerRank, no screen share, roughly 20 minutes each. The rhythm is the key thing to get right:

  1. Restate the problem, confirming edge cases and input bounds;
  2. Explain the approach out loud and wait for the interviewer's nod;
  3. Then write the code;
  4. When done, volunteer the time and space complexity;
  5. The interviewer usually adds 1-2 follow-up constraints — just keep reasoning from there.

You're not required to run code — organizing your thoughts, decomposing, and verbal expression matter far more than the execution result.

Problem 1: Merge Intervals with a Custom Gap Rule

Statement

You're given intervals [start, end]. The classic version only merges overlapping intervals; here there's an extra rule: if the gap between two intervals is <= k, merge them too.

Example: [[1,3],[6,8],[9,10]] with k=2 -> [6,8] and [9,10] have a gap of 1 (<= 2), so they merge into [6,10], giving [[1,3],[6,10]].

Approach

  1. Sort by start;
  2. Scan linearly, keeping the current interval (cur_start, cur_end);
  3. If the next interval has next_start <= cur_end + k, set cur_end = max(cur_end, next_end); otherwise push the current interval and reset to the new one.

Python Solution

def merge_with_gap(intervals, k):
    """Sort by start, then scan linearly; a gap <= k counts as mergeable."""
    if not intervals:
        return []
    # Sort by start so merging only needs to look one step to the right
    intervals.sort(key=lambda x: x[0])
    merged = [list(intervals[0])]
    for start, end in intervals[1:]:
        cur = merged[-1]
        if start <= cur[1] + k:      # gap <= k, merge
            cur[1] = max(cur[1], end)
        else:                        # gap too large, start a new interval
            merged.append([start, end])
    return merged


# Quick self-check
print(merge_with_gap([[1, 3], [6, 8], [9, 10]], 2))  # [[1, 3], [6, 10]]

Time complexity: O(n log n) (sorting dominates) Space complexity: O(n) (the result array)

Common Follow-up

What if the input is streaming / infinite and intervals arrive over time? You can't sort up front. Maintain a balanced tree / ordered structure (or a min-heap of active intervals keyed by arrival), and for each incoming interval locate its left and right neighbors, check whether the gap is <= k, and merge in place — O(log n) per operation.

Problem 2: Longest Alternating-Difference Subarray

Statement

Given an integer array, find the longest contiguous subarray where the sign of consecutive differences alternates.

Example: [1,3,2,4,3] has differences + - + -, alternating throughout, so the whole length-5 array qualifies.

Approach

A brute-force O(n^2) that enumerates start points works, but the optimal is a single linear scan: moving left to right, keep the "current alternating length" and the "sign of the last difference." If the current difference's sign differs from the last one -> extend the length; if it's the same -> restart counting from this pair; if the difference is 0 -> break and reset.

Python Solution

def longest_alternating_subarray(nums):
    """Linear scan keeping the current alternating length and last diff sign."""
    n = len(nums)
    if n < 2:
        return n
    best = 1
    cur = 1          # element count of the current alternating subarray
    last_sign = 0    # 0 means no valid sign yet
    for i in range(1, n):
        diff = nums[i] - nums[i - 1]
        if diff == 0:            # equal values break the run
            cur, last_sign = 1, 0
            continue
        sign = 1 if diff > 0 else -1
        if last_sign != 0 and sign != last_sign:
            cur += 1             # signs alternate, extend
        else:
            cur = 2              # same sign or first diff, restart from this pair
        last_sign = sign
        best = max(best, cur)
    return best


# Quick self-check
print(longest_alternating_subarray([1, 3, 2, 4, 3]))  # 5

Time complexity: O(n) Space complexity: O(1)

Common Follow-up

Modify the array in place so a prefix holds the longest alternating subarray. Use a two-pointer write index: as you scan, keep a write index w and copy the elements of the current longest alternating run back to the front of the array, so the first best positions hold the answer with O(1) extra space.

Stage 3: Your Questions (a few minutes)

A few minutes are reserved for you to ask questions. Ask about the team's product lines, what interns work on day to day, or how Bloomberg's tech stack is evolving. Showing interest in the concrete work scores better than asking "how did I do?"

Prep Strategy

Bloomberg's first round is low-to-medium difficulty and evaluates coding fundamentals plus communication, not exotic algorithms. Focus on:

VO Support / VO Proxy from oavoservice

For a round like this — verbal-reasoning-led and demanding that you talk while you code — oavoservice offers:

For plans and pricing, reach out on WeChat Coding0201.

FAQ

Do I need to get the code running in Bloomberg's first round?

No. The round is on HackerRank but running the code isn't required. The interviewer cares more about whether you can clearly explain your approach, decompose the problem, and give the complexity. Correct, readable code is enough.

Can the project Q&A stage fail me?

Usually not. The project questions are templated (biggest challenge, what you'd improve, team ownership, why Bloomberg) and exist to form a first impression. A 2-minute structured spoken version is plenty.

How hard are the two algorithm problems?

Low-to-medium, roughly LC Easy-Medium, testing coding fundamentals rather than hard algorithms. The real differentiator is verbal reasoning and communication: explain the approach and get the interviewer's buy-in before you start typing.

What direction do the interviewer's follow-ups usually take?

Mostly added constraints. The merge-intervals problem gets "what about streaming / infinite input," and the alternating-subarray problem gets "can you rewrite the array in place." Just push your original approach toward online processing or space optimization.

Is VO support / VO proxy useful for this round?

Yes. This round rewards the "talk while you code" rhythm. VO support lets you drill that rhythm into muscle memory through mocks, while VO proxy provides real-time organization and follow-up handling on interview day — especially helpful if you tend to go silent and just start typing under pressure.

Preparing for a Bloomberg intern VO?

oavoservice tracks Bloomberg's rounds and question style closely, and our mentors understand its verbal-reasoning-led grading. We offer HackerRank-style timed mocks, project-answer script polishing, and follow-up rehearsal as part of our VO support service.

👉 Add WeChat Coding0201 now to get Bloomberg's frequent questions and a VO support plan.

Contact