Projection Area of 3D Shapes - Practice Coding Problems

Projection Area of 3D Shapes - Problem

You are given an n x n grid where we place some 1 x 1 x 1 cubes that are axis-aligned with the x, y, and z axes.

Each value v = grid[i][j] represents a tower of v cubes placed on top of the cell (i, j).

We view the projection of these cubes onto the xy, yz, and zx planes. A projection is like a shadow, that maps our 3-dimensional figure to a 2-dimensional plane. We are viewing the "shadow" when looking at the cubes from the top, the front, and the side.

Return the total area of all three projections.

Input & Output

Example 1 — Basic 2x2 Grid

$ Input: grid = [[1,2],[3,1]]

› Output: 14

💡 Note: XY projection (top view): 4 non-zero cells. YZ projection (front view): max(1,2) + max(3,1) = 2 + 3 = 5. ZX projection (side view): max(1,3) + max(2,1) = 3 + 2 = 5. Total = 4 + 5 + 5 = 14.

Example 2 — Single Row

$ Input: grid = [[2]]

› Output: 5

💡 Note: XY projection: 1 non-zero cell. YZ projection: max height in row = 2. ZX projection: max height in column = 2. Total = 1 + 2 + 2 = 5.

Example 3 — With Zero Heights

$ Input: grid = [[1,0],[0,2]]

› Output: 8

💡 Note: XY projection: 2 non-zero cells. YZ projection: max(1,0) + max(0,2) = 1 + 2 = 3. ZX projection: max(1,0) + max(0,2) = 1 + 2 = 3. Total = 2 + 3 + 3 = 8.

Constraints

n == grid.length == grid[i].length
1 ≤ n ≤ 50
0 ≤ grid[i][j] ≤ 50

Visualization

Tap to expand

Understanding the Visualization

Input Grid

Each cell represents a tower of cubes with given height

Three Projections

Calculate shadow areas from top, front, and side views

Sum Areas

Total area of all three projections

Key Takeaway

🎯 Key Insight: Think of projections as shadows - top view counts occupied spaces, front/side views show maximum heights

Asked in

a Amazon 15 G Google 12

The key insight is understanding that projections are shadows cast from different viewpoints. XY projection counts non-zero cells (top view), YZ projection sums maximum heights per row (front view), and ZX projection sums maximum heights per column (side view). Best approach uses a single pass optimization. Time: O(n²), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Separate Projection Calculations	O(n²)	O(1)	Calculate each projection (xy, yz, zx) separately with multiple grid traversals
Single Pass Optimization	O(n²)	O(n)	Calculate all three projections in one pass through the grid

Brute Force - Separate Projection Calculations — Algorithm Steps

Step 1: Calculate xy projection by counting non-zero grid cells
Step 2: Calculate yz projection by finding maximum height in each row
Step 3: Calculate zx projection by finding maximum height in each column
Step 4: Sum all three projection areas

Visualization

Tap to expand

Step-by-Step Walkthrough

XY Projection (Top View)

Count non-zero cells

YZ Projection (Front View)

Find max height per row

ZX Projection (Side View)

Find max height per column

Code -

solution.c — C

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

int solution(int** grid, int n) {
    // XY projection (top view) - count non-zero cells
    int xyArea = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] > 0) {
                xyArea++;
            }
        }
    }
    
    // YZ projection (front view) - max height in each row
    int yzArea = 0;
    for (int i = 0; i < n; i++) {
        int maxHeight = 0;
        for (int j = 0; j < n; j++) {
            if (grid[i][j] > maxHeight) {
                maxHeight = grid[i][j];
            }
        }
        yzArea += maxHeight;
    }
    
    // ZX projection (side view) - max height in each column
    int zxArea = 0;
    for (int j = 0; j < n; j++) {
        int maxHeight = 0;
        for (int i = 0; i < n; i++) {
            if (grid[i][j] > maxHeight) {
                maxHeight = grid[i][j];
            }
        }
        zxArea += maxHeight;
    }
    
    return xyArea + yzArea + zxArea;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing for small grids
    int n = 0;
    int** grid = malloc(50 * sizeof(int*));
    
    // Count rows by counting opening brackets
    for (int i = 0; input[i]; i++) {
        if (input[i] == '[' && input[i+1] != '[') {
            n++;
        }
    }
    
    // Allocate and parse grid
    for (int i = 0; i < n; i++) {
        grid[i] = malloc(50 * sizeof(int));
    }
    
    // Simple parsing logic for the format [[1,2],[3,4]]
    char* ptr = input;
    int row = 0, col = 0;
    while (*ptr) {
        if (*ptr >= '0' && *ptr <= '9') {
            grid[row][col] = atoi(ptr);
            col++;
            while (*ptr >= '0' && *ptr <= '9') ptr++;
        } else if (*ptr == ']' && *(ptr+1) != ']') {
            row++;
            col = 0;
        } else {
            ptr++;
        }
    }
    
    printf("%d\n", solution(grid, n));
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Three separate passes through n×n grid

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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 - Separate Projection Calculations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler