Buildings With an Ocean View - Practice Coding Problems

Buildings With an Ocean View - Problem

Imagine you're a city planner designing a coastal neighborhood where residents want to enjoy beautiful ocean views! 🏙️🌊

You have n buildings arranged in a straight line along the coast. Each building has a specific height given in an array heights, where heights[i] represents the height of the i-th building. The ocean is located to the right of all buildings.

A building has an ocean view if and only if all buildings to its right are shorter than it. In other words, there are no taller buildings blocking its view to the ocean.

Your task: Return a list of indices (0-indexed) of all buildings that have an unobstructed ocean view, sorted in increasing order.

Example: If buildings have heights [4,2,3,1], then buildings at indices 0, 2, 3 have ocean views because:

Building 0 (height 4): All buildings to its right (2,3,1) are shorter ✅
Building 1 (height 2): Building at index 2 (height 3) is taller ❌
Building 2 (height 3): Building to its right (height 1) is shorter ✅
Building 3 (height 1): No buildings to its right ✅

Input & Output

example_1.py — Basic case

$ Input: [4,2,3,1]

› Output: [0,2,3]

💡 Note: Building 0 (height 4) can see ocean as all buildings to right (2,3,1) are shorter. Building 1 (height 2) cannot see ocean because building 2 (height 3) blocks it. Building 2 (height 3) can see ocean as building 3 (height 1) is shorter. Building 3 (height 1) can see ocean as no buildings are to its right.

example_2.py — Increasing heights

$ Input: [4,3,2,1]

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

💡 Note: All buildings have ocean view because heights are in decreasing order from left to right, so each building can see over all buildings to its right.

example_3.py — Single building

$ Input: [1]

› Output: [0]

💡 Note: With only one building, it automatically has an ocean view since there are no buildings to its right to block the view.

Visualization

Tap to expand

Understanding the Visualization

Setup the buildings

Arrange buildings in a line with ocean to the right

Start from rightmost

The rightmost building always has an ocean view

Scan left

Move left, tracking the tallest building seen so far

Check visibility

Each building taller than the current maximum can see the ocean

Key Takeaway

🎯 Key Insight: By scanning from right to left and tracking the maximum height, we can determine ocean visibility in a single pass, making this an O(n) solution instead of O(n²).

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array from right to left, each element processed once

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables (not counting output array)

✓ Linear Space

Constraints

1 ≤ heights.length ≤ 10⁵
1 ≤ heights[i] ≤ 10⁹
The ocean is to the right of the buildings

Asked in

f Meta 45 a Amazon 32 G Google 28 ⊞ Microsoft 18

The optimal solution uses a right-to-left scan approach with O(n) time complexity. The key insight is that we can determine ocean views by scanning from right to left while tracking the maximum height seen so far. Any building taller than this maximum will have an unobstructed ocean view. This eliminates the need for nested loops and reduces the problem to a single pass through the array.

Common Approaches

Approach	Time	Space	Notes
✓ Right-to-Left Scan (Optimal)	O(n)	O(1)	Scan from right to left, tracking maximum height seen so far
Brute Force (Nested Loops)	O(n²)	O(1)	For each building, check all buildings to its right to see if any are taller

Right-to-Left Scan (Optimal) — Algorithm Steps

Start from the rightmost building (it always has an ocean view)
Keep track of the maximum height seen so far from the right
For each building moving left, if its height is greater than the maximum, it has an ocean view
Update the maximum height as we go
Since we're going right-to-left, reverse the result or use a stack

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from rightmost building

The rightmost building always has ocean view

Track maximum height

Keep track of tallest building seen so far from right

Check each building

If current building > max height, it has ocean view

Update maximum

Update max height and continue left

Code -

solution.c — C

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

void reverse(int* arr, int size) {
    for (int i = 0; i < size / 2; i++) {
        int temp = arr[i];
        arr[i] = arr[size - 1 - i];
        arr[size - 1 - i] = temp;
    }
}

int* findBuildings(int* heights, int n, int* returnSize) {
    int* result = malloc(n * sizeof(int));
    int count = 0;
    int maxHeight = 0;
    
    // Scan from right to left
    for (int i = n - 1; i >= 0; i--) {
        if (heights[i] > maxHeight) {
            result[count++] = i;
            maxHeight = heights[i];
        }
    }
    
    // Reverse to get indices in increasing order
    reverse(result, count);
    *returnSize = count;
    return result;
}

int main() {
    int heights[] = {4, 2, 3, 1};
    int n = 4;
    int returnSize;
    
    int* result = findBuildings(heights, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array from right to left, each element processed once

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables (not counting output array)

✓ Linear Space

Constraints

1 ≤ heights.length ≤ 10⁵
1 ≤ heights[i] ≤ 10⁹
The ocean is to the right of the buildings

42.5K Views

Medium Frequency

~15 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Right-to-Left Scan (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler