Real Interview Questions. Real Insights. Real Results.

I recently completed my onsite interview for a Level 4 Software Engineer position at Sample Company. One of the more intriguing problems was focused on optimizing warehouse loading schedules based on weight constraints.

Problem Breakdown

You’re given a list of delivery packages, each with:

A start time when the package becomes available

An end time by which it must be loaded

A weight

You're also given the maximum weight capacity the truck can carry at any time.

The challenge is to determine whether it’s possible to load all the packages without ever exceeding the weight limit, assuming packages can be loaded or removed at any timestamp within their interval.

packages = [
  (1, 5, 10),   # From time 1 to 5, 10kg
  (3, 7, 15),   # From time 3 to 7, 15kg
  (6, 10, 20)   # From time 6 to 10, 20kg
]

max_capacity = 30

The expected output should list non-overlapping time periods and the personnel active during each:

[
  (1, 2) -> ["Alice"],
  (2, 4) -> ["Alice", "Bob"],
  (4, 5) -> ["Alice", "Bob", "Charlie"],
  (5, 6) -> ["Bob", "Charlie"],
  (6, 8) -> ["Charlie"]
]

Expected Output

True  # It is possible to load all packages without exceeding the weight limit at any time.

Steps:

- Convert package intervals into events

Add a +weight event at start

Add a -weight event at end

- Sort events by time

If two events share the same timestamp, process removals before additions to avoid brief capacity overflow.

- Sweep through the timeline, keeping track of the current total weight.

If total weight ever exceeds max_capacity, return False

If the entire timeline is processed without overflow, return True

Code Implementation (Python)

def can_load_all_packages(packages, max_capacity):
    events = []

    for start, end, weight in packages:
        events.append((start, weight))    # Add weight at start
        events.append((end, -weight))     # Remove weight at end

    # Sort events: prioritize removals over additions at the same time
    events.sort(key=lambda x: (x[0], x[1]))

    current_weight = 0

    for time, weight_change in events:
        current_weight += weight_change
        if current_weight > max_capacity:
            return False

    return True

# Example usage
packages = [(1, 5, 10), (3, 7, 15), (6, 10, 20)]
max_capacity = 30
print(can_load_all_packages(packages, max_capacity))  # Output: True

Key Takeaways

- Line Sweep is extremely effective in time-based event processing.

- Sorting events and processing them in the correct order is key to correctness.

- Always consider edge cases:

Overlapping intervals

Shared timestamps

Zero-length intervals

Tips for Similar Interview Problems

* Look for intervals + constraints. This often points to a line sweep approach.

* Know when to use:

Prefix sums

Sets

Heaps

* Draw a time diagram if you're stuck. Visualizing events helps a lot.

* Practice with similar problems.