Count Covered Buildings - Practice Coding Problems

Count Covered Buildings - Problem

🏙️ City Planning Challenge: Count Covered Buildings

Imagine you're a city planner analyzing building coverage in a grid-based city layout. You have an n × n city grid with various buildings scattered throughout. Your task is to identify which buildings are "covered" - meaning they have protection from all four cardinal directions.

A building at coordinates [x, y] is considered covered if there exists at least one building in each of the four directions:

🡸 Left: At least one building with same y-coordinate but smaller x-coordinate
🡺 Right: At least one building with same y-coordinate but larger x-coordinate
🡹 Above: At least one building with same x-coordinate but smaller y-coordinate
🡻 Below: At least one building with same x-coordinate but larger y-coordinate

Goal: Return the total count of covered buildings in the city.

Input & Output

example_1.py — Small City Grid

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

› Output: 1

💡 Note: Only building at (3,2) is covered. It has building (2,2) to its left, (4,3) area doesn't provide right coverage. Actually, let me recalculate: (3,2) has (2,2) left, no building directly right in row 2, so it's not covered. Building (2,3) has (2,2) above, (3,2) doesn't share row... The building at (3,3) has (2,3) left, no right, (3,2) above, no below in column 3 below row 3. Only (2,3) could be covered: left=(1,1)? No, different row. Actually (2,2) is covered: left=none in row 2, right=(3,2) in row 2, up=none in col 2, down=(2,3) in col 2. So not covered. Let me re-examine: (3,2) has left=(2,2), right=none, up=none, down=(3,3). Not fully covered.

example_2.py — Cross Pattern

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

› Output: 1

💡 Note: Building at (2,2) is covered because it has (1,2) to the left, (3,2) to the right, (2,1) above, and (2,3) below. It's the center of a cross pattern.

example_3.py — No Coverage

$ Input: n = 3, buildings = [[1,1],[3,3]]

› Output: 0

💡 Note: Neither building has coverage in all four directions since they don't share rows or columns with other buildings.

Constraints

1 ≤ n ≤ 1000
1 ≤ buildings.length ≤ n²
buildings[i].length == 2
1 ≤ buildings[i][0], buildings[i][1] ≤ n
All buildings have unique coordinates

Visualization

Tap to expand

Understanding the Visualization

Map the City

Create hash maps grouping buildings by rows and columns

Check Coverage

For each building, verify neighbors exist in all four directions

Count Approved

Sum up buildings that have complete directional coverage

Key Takeaway

🎯 Key Insight: Group buildings by coordinates to transform O(n²) pairwise comparisons into efficient O(1) directional lookups!

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses hash tables to group buildings by their x and y coordinates, enabling O(1) lookup of buildings in the same row or column. This reduces the time complexity from O(n²) brute force to O(n×k) where k is the average number of buildings per row/column.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check every building against every other building for coverage in all four directions
Hash Table Optimization (Optimal)	O(n × k)	O(n)	Use hash maps to group buildings by coordinates for O(1) direction lookups

Brute Force (Nested Loops) — Algorithm Steps

For each building at position (x, y)
Initialize four boolean flags for directions: left, right, up, down
Check every other building to see if it provides coverage in any direction
If a building has coverage in all four directions, increment the counter
Return the total count of covered buildings

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Target

Pick a building to check for coverage

Scan All Others

Check every other building for directional coverage

Verify Coverage

Confirm all four directions have at least one building

Code -

solution.c — C

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

int countCoveredBuildings(int n, int buildings[][2], int buildingsSize) {
    int count = 0;
    
    for (int i = 0; i < buildingsSize; i++) {
        int x = buildings[i][0], y = buildings[i][1];
        bool left = false, right = false, up = false, down = false;
        
        for (int j = 0; j < buildingsSize; j++) {
            if (i == j) continue;
            
            int bx = buildings[j][0], by = buildings[j][1];
            
            if (by == y && bx < x) left = true;
            else if (by == y && bx > x) right = true;
            else if (bx == x && by < y) up = true;
            else if (bx == x && by > y) down = true;
        }
        
        if (left && right && up && down) {
            count++;
        }
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n buildings, we check against all other n-1 buildings

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few boolean variables and counters

✓ Linear Space

28.5K Views

Medium Frequency

~18 min Avg. Time

847 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

🏙️ City Planning Challenge: Count Covered Buildings

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler