Average Height of Buildings in Each Segment

Average Height of Buildings in Each Segment - Problem

Imagine you're a city planner analyzing building heights along a perfectly straight street! 🏙️

You're given a 2D array buildings where each buildings[i] = [start, end, height] represents a building with height covering the half-closed interval [start, end) on the street.

Your task is to divide the street into segments where each segment has a constant average building height. Return these segments as [[left, right, average], ...] using the minimum number of non-overlapping segments.

Key Points:

Half-closed interval [a, b) includes a but excludes b
Average is calculated using integer division
Only include segments where buildings exist
Segments can be returned in any order

Example: If buildings = [[1,5,2],[3,10,4]]
→ Street segments: [[1,3,2], [3,5,3], [5,10,4]]
→ From 1-3: only first building (avg = 2/1 = 2)
→ From 3-5: both buildings (avg = (2+4)/2 = 3)
→ From 5-10: only second building (avg = 4/1 = 4)

Input & Output

example_1.py — Basic Case

$ Input: buildings = [[1,5,2],[3,10,4]]

› Output: [[1,3,2],[3,5,3],[5,10,4]]

💡 Note: From 1-3: only building 1 exists (avg=2). From 3-5: both buildings exist (avg=(2+4)/2=3). From 5-10: only building 2 exists (avg=4).

example_2.py — Multiple Overlaps

$ Input: buildings = [[1,4,2],[3,9,4],[6,7,1]]

› Output: [[1,3,2],[3,4,3],[4,6,4],[6,7,2],[7,9,4]]

💡 Note: Complex overlapping pattern creates 5 distinct segments with different average heights.

example_3.py — Single Building

$ Input: buildings = [[0,2,3]]

› Output: [[0,2,3]]

💡 Note: With only one building, the entire segment has that building's height as the average.

Constraints

1 ≤ buildings.length ≤ 1000
buildings[i].length == 3
0 ≤ start_i < end_i ≤ 10⁸
1 ≤ height_i ≤ 1000
Half-closed intervals: [start, end) includes start but excludes end

Visualization

Tap to expand

Understanding the Visualization

Identify Critical Points

Mark all building start and end positions - these are where average heights change

Sort Boundary Points

Arrange all critical coordinates in ascending order for sweep line processing

Sweep and Calculate

Move through each segment, count overlapping buildings, and compute average heights

Generate Result

Output segments as [left, right, average] tuples for city planning report

Key Takeaway

🎯 Key Insight: Average heights only change at building boundaries. By processing just these critical points instead of every coordinate, we achieve optimal O(N log N) performance!

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses coordinate compression with a sweep line algorithm. Instead of checking every possible coordinate, we identify critical points (building boundaries), sort them, and process only the segments between these points. This reduces time complexity to O(N log N) and handles large coordinate ranges efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Point-by-Point)	O(R × N)	O(R)	Check every coordinate point individually and group consecutive points with same averages
Coordinate Compression (Optimal)	O(N log N)	O(N)	Use coordinate compression with sweep line algorithm to efficiently process only critical points

Brute Force (Point-by-Point) — Algorithm Steps

Find the range of all coordinates (min start to max end)
For each coordinate point, count buildings and calculate average height
Group consecutive points with identical averages into segments
Convert groups into [left, right, average] format

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Range

Determine min and max coordinates

Check Each Point

For each coordinate, count overlapping buildings

Calculate Average

Compute average height at each point

Group Segments

Merge consecutive points with same average

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int** averageHeightOfBuildings(int** buildings, int buildingsSize, int* buildingsColSize, int* returnSize, int** returnColumnSizes) {
    if (buildingsSize == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int minCoord = INT_MAX, maxCoord = INT_MIN;
    for (int i = 0; i < buildingsSize; i++) {
        if (buildings[i][0] < minCoord) minCoord = buildings[i][0];
        if (buildings[i][1] > maxCoord) maxCoord = buildings[i][1];
    }
    
    int* averages = (int*)malloc((maxCoord - minCoord) * sizeof(int));
    for (int coord = minCoord; coord < maxCoord; coord++) {
        int totalHeight = 0, count = 0;
        
        for (int i = 0; i < buildingsSize; i++) {
            if (buildings[i][0] <= coord && coord < buildings[i][1]) {
                totalHeight += buildings[i][2];
                count++;
            }
        }
        
        averages[coord - minCoord] = (count > 0) ? (totalHeight / count) : -1;
    }
    
    int** result = (int**)malloc(buildingsSize * sizeof(int*));
    *returnColumnSizes = (int*)malloc(buildingsSize * sizeof(int));
    *returnSize = 0;
    
    int i = 0;
    while (i < maxCoord - minCoord) {
        if (averages[i] != -1) {
            int start = minCoord + i;
            int currentAvg = averages[i];
            
            while (i < maxCoord - minCoord && averages[i] == currentAvg) {
                i++;
            }
            
            result[*returnSize] = (int*)malloc(3 * sizeof(int));
            result[*returnSize][0] = start;
            result[*returnSize][1] = minCoord + i;
            result[*returnSize][2] = currentAvg;
            (*returnColumnSizes)[*returnSize] = 3;
            (*returnSize)++;
        } else {
            i++;
        }
    }
    
    free(averages);
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(R × N)

Where R is coordinate range and N is number of buildings - we check every point in range

✓ Linear Growth

Space Complexity

O(R)

Store height information for every coordinate point

✓ Linear Space

68.4K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Point-by-Point) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler