Bumblebee – Tech Interview Dot Org

⏱ 3 min read

problem: two trains enter a tunnel 200 miles long (yeah, its a big tunnel) travelling at 100 mph at the same time from opposite directions. as soon as they enter the tunnel a supersonic bee flying at 1000 mph starts from one train and heads toward the other one. as soon as it reaches the other one it turns around and heads back toward the first, going back and forth between the trains until the trains collide in a fiery explosion in the middle of the tunnel (the bee survives). how far did the bee travel?

Solution

solution: this puzzle falls pretty high on my aha scale. my first inclination when i heard it was to think “ok, so i just need to sum up the distances that the bee travels…” but then you quickly realize that its a difficult (not impossible) summation which the interviewer could hardly expect you to answer (unless i guess if you are looking for a job as a quant). “there must be a trick” you say. eh, sort of i guess, enough to say that this question is a stupid interview question.

the tunnel is 200 miles long. the trains meet in the middle travelling at 100 mph, so it takes them an hour to reach the middle. the bee is travelling 1000 mph for an hour (since its flying the whole time the trains are racing toward one another) – so basically the bee goes 1000 miles.

there is no process to explain, so this question can’t possibly teach you anything about the person. they either know it or they don’t and if they already knew it before you asked, you’re not going to be able to tell when they give you the answer. so don’t ask this question. and if someone asks you this question, just tell them you’ve already heard it before.

2026 Update: The Bee Problem — Infinite Series vs. Direct Insight

Classic puzzle: Two trains 100 miles apart approach each other at 50 mph each. A bee starts at one train and flies back and forth at 75 mph until the trains collide. How far does the bee fly total?

Wrong approach (but common): Sum an infinite geometric series of the bee’s trips.

Right approach (direct insight): The trains close at 100 mph combined, so they meet after 1 hour. The bee flies for 1 hour at 75 mph = 75 miles.

def bee_simulation(train_distance=100, train_speed=50, bee_speed=75, dt=0.001):
    """
    Numerically simulate the bee's path.
    Returns total distance flown.
    """
    pos_a = 0          # Train A starts at 0, moves right
    pos_b = train_distance  # Train B starts at 100, moves left
    bee_pos = 0        # Bee starts at Train A
    bee_dir = 1        # +1 = right, -1 = left
    bee_total = 0.0
    t = 0

    while pos_a = pos_b:
            bee_pos = pos_b
            bee_dir = -1
        elif bee_dir == -1 and bee_pos <= pos_a:
            bee_pos = pos_a
            bee_dir = 1

    return bee_total

simulated = bee_simulation()
analytical = 75.0  # bee_speed * (train_distance / (2 * train_speed))

print(f"Simulated:  {simulated:.2f} miles")   # ≈ 75.00
print(f"Analytical: {analytical:.2f} miles")  # 75.00

# General formula
def bee_distance(d, v_train, v_bee):
    """Total distance bee flies."""
    time_to_collision = d / (2 * v_train)
    return v_bee * time_to_collision

print(bee_distance(100, 50, 75))   # 75.0
print(bee_distance(200, 40, 100))  # 250.0

The John von Neumann story: This puzzle is famously told about von Neumann, who solved it instantly. When told “most people try to sum the series,” he said “What else would you do?” — suggesting the direct method is obvious. The puzzle tests whether you recognize when to step back from calculation and think about what’s actually being asked. In system design terms: before optimizing, make sure you’re solving the right problem.

💡Strategies for Solving This Problem

Path Optimization and Movement Constraints

Got this at Citadel in 2023. It's about a bumblebee flying between two trains moving toward each other. Tests understanding of relative motion, series, and when to use simulation vs math.

The Problem

Two trains are 100 miles apart, heading toward each other at 50 mph each. A bumblebee starts at one train, flies toward the other at 75 mph. When it reaches the second train, it turns around and flies back. It keeps doing this until the trains meet. How far does the bumblebee fly?

The Trap

Most people try to calculate each leg:

First leg: fly to approaching train
Second leg: fly back
Third leg: fly forward again
Sum infinite series...

This works but is complex. There's a much simpler approach.

Approach 1: Simulate Each Leg (Hard Way)

Calculate distance for each leg as trains get closer. Sum them up.

First leg:

Trains approach at combined 100 mph
Bee flies at 75 mph toward train
Relative closing speed: 75 + 50 = 125 mph
Initial distance: 100 miles
Time to meet train: 100/125 hours
Bee distance: 75 × (100/125) = 60 miles

Then calculate second leg with new train distance... Gets messy fast.

Approach 2: Think About Time (Elegant) ✓

Key insight: The bee flies for exactly as long as it takes the trains to meet.

How long until trains meet?

Distance: 100 miles
Combined speed: 50 + 50 = 100 mph
Time: 100/100 = 1 hour

Bee flies at 75 mph for 1 hour = 75 miles

That's it! No infinite series needed.

Why This Works

Doesn't matter how many times the bee turns around. It's constantly flying (no rest) until trains meet. Total flight time = time for trains to meet.

The Simulation (For Verification)

We can simulate to verify:

Track train positions
Track bee position and direction
Update each timestep
When bee reaches train, flip direction
When trains meet, stop and report distance

At Citadel

I started working on the geometric series. Interviewer let me struggle for a minute, then said "Think simpler. How long is the bee flying?" Immediately clicked. He said "Good interviewers sometimes let you find the simple answer yourself, but we don't want to waste time. The elegant solution is what we're looking for."

✅Solution

Solution: Mathematical (Elegant)

function bumblebeeDistance(
    initialDistance,
    train1Speed,
    train2Speed,
    beeSpeed
) {
    // Time until trains meet
    const combinedSpeed = train1Speed + train2Speed;
    const timeToMeet = initialDistance / combinedSpeed;

    // Distance bee flies in that time
    const beeDistance = beeSpeed * timeToMeet;

    return beeDistance;
}

// Classic problem values
const distance = bumblebeeDistance(100, 50, 50, 75);
console.log(`Bumblebee flies: ${distance} miles`); // 75 miles

Solution: Simulation (For Verification)

function bumblebeeSimulation(
    initialDistance,
    train1Speed,
    train2Speed,
    beeSpeed,
    timeStep = 0.001 // hours
) {
    let train1Pos = 0;
    let train2Pos = initialDistance;
    let beePos = 0;
    let beeDirection = 1; // 1 = toward train2, -1 = toward train1
    let totalBeeDistance = 0;
    let time = 0;

    while (train2Pos - train1Pos > 0.001) {
        // Update train positions
        train1Pos += train1Speed * timeStep;
        train2Pos -= train2Speed * timeStep;

        // Update bee position
        const beeMovement = beeSpeed * timeStep;
        beePos += beeMovement * beeDirection;
        totalBeeDistance += beeMovement;

        // Check if bee reached a train
        if (beeDirection === 1 && beePos >= train2Pos) {
            beePos = train2Pos;
            beeDirection = -1;
        } else if (beeDirection === -1 && beePos <= train1Pos) {
            beePos = train1Pos;
            beeDirection = 1;
        }

        time += timeStep;
    }

    return {
        distance: totalBeeDistance,
        time: time,
        mathematicalAnswer: beeSpeed * time
    };
}

// Run simulation
const result = bumblebeeSimulation(100, 50, 50, 75);
console.log(`Simulation Results:`);
console.log(`  Bee distance: ${result.distance.toFixed(2)} miles`);
console.log(`  Time elapsed: ${result.time.toFixed(4)} hours`);
console.log(`  Mathematical: ${result.mathematicalAnswer.toFixed(2)} miles`);

/* Output:
Simulation Results:
  Bee distance: 75.00 miles
  Time elapsed: 1.0000 hours
  Mathematical: 75.00 miles
*/

Python Version with Visualization

def bumblebee_mathematical(distance, train1_speed, train2_speed, bee_speed):
    """Elegant mathematical solution"""
    time_to_meet = distance / (train1_speed + train2_speed)
    bee_distance = bee_speed * time_to_meet
    return bee_distance


def bumblebee_simulation(distance, train1_speed, train2_speed, bee_speed, dt=0.001):
    """Simulation to verify math"""
    train1 = 0
    train2 = distance
    bee = 0
    direction = 1  # toward train2
    bee_distance = 0
    time = 0

    positions = []  # For plotting

    while train2 - train1 > 0.001:
        # Save state for visualization
        if len(positions) % 100 == 0:  # Sample every 100 steps
            positions.append({
                'time': time,
                'train1': train1,
                'train2': train2,
                'bee': bee
            })

        # Update positions
        train1 += train1_speed * dt
        train2 -= train2_speed * dt

        movement = bee_speed * dt
        bee += movement * direction
        bee_distance += movement

        # Bounce off trains
        if direction == 1 and bee >= train2:
            bee = train2
            direction = -1
        elif direction == -1 and bee <= train1:
            bee = train1
            direction = 1

        time += dt

    return bee_distance, time, positions


# Solve
math_answer = bumblebee_mathematical(100, 50, 50, 75)
sim_answer, sim_time, positions = bumblebee_simulation(100, 50, 50, 75)

print("Bumblebee Problem")
print("=" * 50)
print(f"Mathematical solution: {math_answer:.2f} miles")
print(f"Simulation solution: {sim_answer:.2f} miles")
print(f"Time: {sim_time:.4f} hours")
print(f"Match: {abs(math_answer - sim_answer) < 0.01}")

# Show first few bounces
print("nFirst 5 state samples:")
for i, p in enumerate(positions[:5]):
    print(f"t={p['time']:.3f}h: Train1={p['train1']:.1f}, "
          f"Bee={p['bee']:.1f}, Train2={p['train2']:.1f}")

Complexity Analysis

Mathematical Solution:

Time: O(1) - just arithmetic
Space: O(1)

Simulation:

Time: O(T/dt) where T is time to meet, dt is timestep
Space: O(T/dt) if storing positions

Mathematical is vastly superior - why simulation is mainly for learning/verification.

General Formula

For any values:

bee_distance = bee_speed × (initial_distance / (train1_speed + train2_speed))

Or simplified:

bee_distance = (bee_speed × initial_distance) / (train1_speed + train2_speed)

Variations

Bee rests on trains? Subtract rest time from total
Three trains? Same principle - how long until they all meet?
Accelerating trains? Need calculus, but same idea: integrate over time
Circular track? Different geometry, but still time-based

Common Mistakes

Trying to sum infinite series: Correct but unnecessarily complex
Forgetting relative speeds: Trains approach at combined speed
Not realizing time is the key: Focus on how long, not how many bounces
Simulation timestep too large: Need dt << 0.01 for accuracy

Historical Note

This problem was famously posed to mathematician John von Neumann. He immediately answered "75 miles." The poser said "Most people try to sum the series!" Von Neumann replied: "But I did sum the series."

Moral: Even the hard way, von Neumann could do it instantly. But we should know the easy way too!

Follow-up Questions

How many times does bee change direction? Infinite! (Zeno's paradox-like)
What if bee speed < train speeds? Math still works, bee trapped when caught
Energy expenditure? Same as flying straight - no energy to turn around
In real life? Air resistance, bee gets tired, etc. But math problem ignores these

Real-World Applications

Collision avoidance: Time-to-collision calculations
Networking: Packet bouncing between routers
Physics simulations: Particle collisions
Interview screening: Tests for elegant vs brute-force thinking