Bumblebee

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

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

Common Mistakes

1. Trying to sum infinite series: Correct but unnecessarily complex
2. Forgetting relative speeds: Trains approach at combined speed
3. Not realizing time is the key: Focus on how long, not how many bounces
4. 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

1. How many times does bee change direction? Infinite! (Zeno's paradox-like)
2. What if bee speed < train speeds? Math still works, bee trapped when caught
3. Energy expenditure? Same as flying straight - no energy to turn around
4. 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

Related Problems

• Clock - Physics and geometry
• Fuse on Fire - Time-based puzzles
• Classic Weighing - Logic problems