1762. Buildings With an Ocean View - Detailed Explanation

Free Coding Questions Catalog

Boost your coding skills with our essential coding questions catalog. Take a step towards a better tech career now!

Problem Statement

Definition: We have n buildings in a row, represented by an array heights where heights[i] is the height of the building at index i. The ocean lies to the right of the last building. A building has an "ocean view" if it can look out to the right and see the ocean without any taller building blocking its view. Formally, a building has an ocean view if all buildings to its right are of smaller height. In other words, if there is any building to the right that is equal or taller in height, then the view is blocked.

The task is to return the indices of all buildings that have an ocean view. Indices are 0-indexed (the first building is index 0), and the result should be sorted in increasing order (from leftmost building to rightmost).

Understanding the Scenario: Imagine standing on each building and looking toward the ocean on the right. If every building further to the right is shorter, then nothing on the horizon blocks your view of the ocean. The rightmost building (last in the array) always has an ocean view because there are no buildings beyond it. A taller building will block all smaller or equal-height buildings to its left from seeing the ocean.

Let's go through some examples to clarify:

Example 1:
Input: heights = [4, 2, 3, 1]
Output: [0, 2, 3]
Explanation:
- Building at index 0 has height 4. All buildings to its right (heights 2, 3, 1) are shorter than 4, so index 0 sees the ocean.
- Building at index 1 has height 2. There is a building to its right (at index 2 with height 3) that is taller, so index 1 is blocked by building 2.
- Building at index 2 has height 3. The only building to its right (index 3 with height 1) is shorter, so index 2 has a clear view.
- Building at index 3 has height 1. It's the last building, so it always sees the ocean.
  Thus, the buildings at indices 0, 2, and 3 have ocean views.
Example 2:
Input: heights = [4, 3, 2, 1]
Output: [0, 1, 2, 3]
Explanation: The heights are in strictly decreasing order. Each building is taller than any building to its right, so every building can see the ocean. The output includes all indices 0 through 3.
Example 3:
Input: heights = [1, 3, 2, 4]
Output: [3]
Explanation: The heights are in increasing order from left to right. The rightmost building (index 3, height 4) sees the ocean by default. Every other building is blocked by a taller building somewhere to its right:
- Index 0 (height 1) is blocked by index 1 (height 3).
- Index 1 (height 3) is blocked by index 3 (height 4), which is taller.
- Index 2 (height 2) is also blocked by index 3 (height 4).
  Only index 3 has an ocean view.
Example 4:
Input: heights = [2, 2, 2, 2]
Output: [3]
Explanation: All buildings have the same height. The first three buildings (indices 0, 1, 2) are blocked by another building of equal height to their right. For instance, building 0 (height 2) has building 1 (height 2) to its right which is not shorter, so that blocks the view. Only the last building (index 3) can see the ocean, since there are no buildings to its right at all.

These examples illustrate the rule: a building can see the ocean if every building to its right is strictly lower in height. We need to find all such buildings and list their indices in ascending order.

Hints to Guide the Solution

Hint 1: Consider the rightmost building first. Since the ocean is on the right side, the last building will always have an unobstructed view. This can serve as a starting point or reference for the solution.
Hint 2: If you move from right-to-left (starting at the end and moving to the beginning of the array), you can keep track of the tallest building seen so far on the right. This will help determine if the current building is taller than all those to its right.
Hint 3: Whenever you examine a building, compare its height with the maximum height of any building to its right. If the current building’s height is greater, it means it towers over all to its right and thus has an ocean view.
Hint 4: Think about what data structure or approach could efficiently keep track of the “tallest to the right”. A simple variable might suffice if you traverse from the ocean side. Alternatively, consider if a stack could be useful to maintain a monotonic (ordered) structure of heights seen so far.
Hint 5: Don’t forget that the problem asks for indices in increasing (left-to-right) order. If you collect results starting from the right side, you may need to reverse or sort the results at the end.

Using these hints, you should be able to derive an efficient strategy to identify all buildings with an ocean view.

Brute Force Approach

A straightforward way to solve the problem is to directly apply the definition: for each building, check every building to its right and see if any of them is taller (or equal in height). If none is taller, then the building has an ocean view.

Naive Strategy:
For each index i from 0 to n-2 (we can skip the last building, since it’s automatically visible), do the following:

Look at all buildings j where j > i (to the right of building i).
If you find any building j such that heights[j] >= heights[i], then building i's view is blocked (either by a taller or equal-height building). In that case, stop checking further to the right for this building.
If you finish checking all buildings to the right and none was as tall or taller, then building i can see the ocean. Record index i as having an ocean view.
Always include the last building (index n-1) as visible, since the loop might skip it.

Using this method, you would ultimately collect all indices that passed the test. If you collect them in increasing order (by iterating i from 0 upwards), the resulting list will already be sorted as required.

Example (Brute Force): Consider heights = [4, 2, 3, 1]:

For index 0 (height 4), check indices 1, 2, 3. The heights to the right are [2, 3, 1]; none of these is >= 4, so index 0 qualifies.
For index 1 (height 2), check indices 2, 3. To the right are [3, 1]; index 2 has height 3 which is >= 2, so index 1 is disqualified (blocked by height 3).
For index 2 (height 3), check index 3. To the right is [1]; 1 < 3, so no blocker, index 2 qualifies.
Index 3 automatically qualifies (last building).
This yields indices [0, 2, 3], which matches the expected result.

Why it’s inefficient: This brute-force solution checks many unnecessary comparisons. In the worst case (like a strictly increasing height sequence), for each building you might compare with every other building to its right. This results in a nested loop structure: for building 0 you check n-1 others, for building 1 check n-2 others, and so on. The time complexity of this approach is O(n²), which becomes very slow as n grows. For example, if n = 100,000, an O(n²) approach could require on the order of 10¹0 operations – far too many to run in a reasonable time.

While the brute force approach is conceptually simple and works for small inputs, it will not scale to large inputs within the problem’s constraints. We need a more efficient solution.

Optimized Approaches

To optimize, we should avoid redundant comparisons. The key observation is that when scanning from the right (the ocean side), we can make a single pass and determine ocean views without checking every pair of buildings repeatedly.

Right-to-Left Traversal (Efficient Solution)

Idea: Start from the rightmost building and move leftwards. Keep track of the highest height seen so far to the right of the current building. This “max height to the right” serves as a threshold: if the current building is taller than this threshold, it means it’s taller than all buildings to its right (because this threshold is the tallest to its right). Thus, the current building has an ocean view. Then update the threshold if needed.

Why this works: When moving from right to left, by the time you reach a building at index i, you have already seen all buildings with greater index (to its right). If you maintain the maximum height among those seen, you can decide in O(1) time whether building i is taller than everything to its right:

Let max_height_right be the maximum height of all buildings to the right of i that we have seen so far.
If heights[i] > max_height_right, then building i can see the ocean (because every building to its right is lower).
If heights[i] <= max_height_right, then there is some building to the right that is equal or taller, blocking the view, so i is not visible.

By iterating this way, each building is considered once, and we do a constant amount of work (one comparison and maybe an update) for each building.

Algorithm (Right-to-Left):

Initialize an empty list (or vector) visible_indices to store indices of buildings with ocean view.
Initialize a variable max_height_right = 0 (or even -∞ theoretically) to keep track of the tallest height seen to the right so far. (We can start with 0 because heights are positive; no building will be shorter than 0.)
Traverse the array from the last index down to 0:
- For each index i, compare heights[i] to max_height_right.
- If heights[i] is greater than max_height_right, this means building i stands taller than all buildings we’ve seen to its right. Mark this building as having an ocean view (e.g., append i to visible_indices).
- Update max_height_right to max(max_height_right, heights[i]). (After processing building i, it becomes part of the "seen" set to the left of the next buildings we will check.)
After finishing the loop, visible_indices will contain the indices of all buildings that can see the ocean, but in reverse order (right-to-left order). The last building processed (index 0) ends up last in the list if it was visible. If the problem requires indices in increasing order, reverse this list before returning it.
Return the sorted list of visible building indices.

Example Walkthrough (Right-to-Left):
Consider heights = [4, 2, 3, 1] again. We traverse from rightmost to leftmost:

Start with max_height_right = 0 and visible_indices = [] (empty).
Step 1: i = 3 (rightmost building, height = 1). Compare 1 to max_height_right (0).
1 > 0, so building 3 is taller than everything to its right (there’s nothing to its right actually). Mark index 3 as visible.
Update max_height_right = 1.

State: visible_indices = [3], max_height_right = 1.
Step 2: i = 2 (height = 3). Compare 3 to max_height_right (1).
3 > 1, so building 2 is taller than all buildings to its right (the only building to its right had height 1). Mark index 2 as visible.
Update max_height_right = 3 (since 3 is the new highest to the right of any building we’ll see next).
State: visible_indices = [3, 2], max_height_right = 3.
Step 3: i = 1 (height = 2). Compare 2 to max_height_right (3).
2 > 3 is false – in fact 2 <= 3, so building 1 is not taller than the max to its right. This means there is a building (index 2 with height 3) blocking the view of building 1. We do not add index 1.
Update max_height_right remains 3 (since 2 is not greater than 3).
State: visible_indices = [3, 2], max_height_right = 3.
Step 4: i = 0 (height = 4). Compare 4 to max_height_right (3).
4 > 3, so building 0 is taller than all buildings to its right. Mark index 0 as visible.
Update max_height_right = 4.
State: visible_indices = [3, 2, 0], max_height_right = 4.
We have finished scanning all buildings. Right now visible_indices = [3, 2, 0], which is in reverse order (from rightmost visible to leftmost visible).
Reverse the list to get [0, 2, 3], which is in increasing index order as required.

This matches the expected output. The algorithm correctly identified buildings 0, 2, and 3 as having an ocean view, by scanning once from the right.

Efficiency: This approach only makes one pass through the array, doing O(1) work for each element, resulting in O(n) time complexity. We use only a few extra variables (and the output list), so the space complexity is minimal. We’ll analyze complexity more formally in a later section.

Using a Monotonic Stack (Alternate Solution)

Another efficient method is to use a monotonic stack to achieve a similar result. A stack can help keep track of candidates that have an ocean view in a structured way.

Idea: Traverse from right to left, and use a stack to maintain the indices of buildings that have an ocean view encountered so far. Ensure that the stack always keeps indices of buildings in decreasing order of height (the stack represents visible buildings, and their heights will naturally be in strictly increasing order from top to bottom if we only push taller buildings).

Algorithm (Stack approach):

Initialize an empty stack (to store indices of visible buildings).
Loop i from n-1 down to 0:
- While the stack is not empty and the height of the building at the top of the stack (heights[stack.peek()]) is less than or equal to heights[i], pop the stack. (This step would remove any building from consideration that is shorter than or equal to the current one, because if the current building is taller or equal, it will block those smaller ones from the perspective of any building further left.)
- Push the current index i onto the stack.
After processing all buildings, the stack contains the indices of all buildings with ocean views, but in decreasing index order (right-to-left). You can then pop or reverse the stack into a list to output the indices in increasing order.

In this particular problem, an optimization is that we might not even need the inner while loop to pop in step 2. If we examine the condition:

We only pop when we find a building taller than those in the stack. But recall that if a building is taller than another to its right, both can still have ocean views (the shorter one to the right is still unobstructed from its perspective, as discussed). So, we actually would not pop shorter buildings that are already known to have views. We simply ensure we push a building if it’s taller than the one at the stack top (meaning it has a view).
A simpler logic for this problem: if the stack is empty (no building seen yet) or the current building’s height is greater than the height of the building at the stack’s top, then push the current index on the stack. This effectively keeps only those buildings that are taller than any seen to their right.

Using that logic:

Traverse from rightmost to leftmost.
If stack is empty or heights[i] > heights[stack.peek()], push i on stack (meaning building i has a view).
Otherwise (if heights[i] <= heights[stack.peek()]), do nothing (building i is blocked by a taller or equal building to its right).
Finally, reverse the stack (since it will hold visible indices right-to-left) to get the result in ascending order.

Note: This stack approach yields the same result as the direct right-to-left traversal above. In fact, it’s conceptually similar – the stack is just storing the results as we go. The benefit of describing the stack method is that it’s a common pattern (monotonic stack) used in many array problems (like "Next Greater Element" or "Daily Temperatures"), and it can be extended if the problem had been asking something slightly different (like actually needing to remove blocked buildings dynamically).

Example (Stack): Using the earlier example heights = [4, 2, 3, 1]:

Start with an empty stack.
i = 3 (height 1): stack is empty, push 3. Stack now [3].
i = 2 (height 3): compare to height at stack top (height[3] = 1). 3 > 1, so push 2. Stack now [3, 2].
i = 1 (height 2): compare to height at stack top (height[2] = 3). 2 is not greater, so do not push 1 (building 1 is blocked). Stack remains [3, 2].
i = 0 (height 4): compare to height at stack top (height[2] = 3). 4 > 3, push 0. Stack now [3, 2, 0].
Reverse stack to get [0, 2, 3].

We get the same result. This method also operates in O(n) time (each building index is pushed and possibly compared/popped a constant number of times) and uses O(n) space in the worst case (the stack could hold all building indices if heights are strictly increasing from right to left).

Choosing an Approach: Both the right-to-left single-pass and the stack approach are efficient and yield correct results. The direct traversal with a max_height is a bit simpler to implement and uses less extra space, which makes it a great choice. The monotonic stack approach is conceptually instructive and is useful in variants of the problem or related problems, but for this specific task it’s somewhat redundant. We will proceed with the simpler right-to-left traversal in code, but it’s good to be aware of the stack method as well.

Code Implementations

Below are implementations of the optimized solution in both Python and Java. Each includes a simple test in the main function to demonstrate usage and verify the output on the examples discussed.

Python Implementation

Python3

. . . .

Explanation: The function findBuildings implements the right-to-left traversal described. We initialize max_height_to_right as 0 and iterate from the last index down to 0. Whenever we find a building taller than max_height_to_right, we add its index to visible_indices and update max_height_to_right. After the loop, we reverse visible_indices to convert from right-to-left order to increasing index order.

The if __name__ == "__main__": block tests the function on several cases:

[4,2,3,1] should output [0,2,3]
[4,3,2,1] should output [0,1,2,3] (all buildings visible)
[1,3,2,4] should output [3] (only the last building visible)
[2,2,2,2] should output [3] (only the last building visible)
[1] (single building) should output [0] (itself)

Java Implementation

Java

. . . .

Explanation: The findBuildings method in Java uses a similar approach. We use an ArrayList<Integer> to collect visible building indices while scanning from right to left with a maxHeight variable. We then reverse this list and convert it to an array of integers to return (since the problem likely expects an array output). The main method demonstrates the function with test cases, printing the input and resulting output for verification.

For instance, running this main method would print:

Input: [4, 2, 3, 1] -> Output: [0, 2, 3]  
Input: [4, 3, 2, 1] -> Output: [0, 1, 2, 3]  
Input: [1, 3, 2, 4] -> Output: [3]  
Input: [2, 2, 2, 2] -> Output: [3]  
Input: [1] -> Output: [0]

matching the expected results for the examples.

Complexity Analysis

Let n be the number of buildings (length of the heights array).

Brute Force Approach: For each building (n choices) you potentially scan all buildings to its right (up to n choices in worst case). This leads to roughly n + (n-1) + (n-2) + ... + 1 comparisons in the worst case, which is on the order of n². So the time complexity is O(n²). This becomes infeasible for large n (for example, if n = 100,000, n² = 10¹0). The space complexity is O(1) extra space (not counting the output list), since it only uses a few counters or flags; we might use an index list for output but that is at most size n.
Optimized Right-to-Left Traversal: We make one pass through the array, doing a constant amount of work (comparison and maybe an update) for each building. This yields a time complexity of O(n). The space complexity is O(1) extra space (again, not counting the output). We only use a couple of variables (max_height_right and a loop index, for example) and an output list. The output list in worst case could hold all n indices (if every building sees the ocean, like in a strictly decreasing height sequence), but that’s required output, not really extra working space.
Monotonic Stack Approach: The time complexity is also O(n). Each building index is pushed onto the stack at most once and popped at most once (if we used the pop approach), or in the simplified version, we do at most one comparison per building. Stack operations are O(1) each. The space complexity in the worst case is O(n) for the stack (in the scenario where each new building is shorter than the previous one to its right, we’d end up pushing all of them onto the stack). Again, not counting the output list/array.

In summary, the optimized solutions both run in linear time, which is a dramatic improvement over the quadratic brute-force method, and use minimal extra space. This allows the solution to comfortably handle the maximum input size (up to 100,000 buildings as per constraints).

Step-by-Step Walkthrough

To further illustrate how the efficient solution works, let's do a detailed step-by-step simulation with a visual mindset. We will use the right-to-left traversal method on an example array and track all relevant information at each step.

Imagine the buildings as bars of different heights:

Index:      0   1   2   3   4
Heights:    5   3   8   4   2

Here, n = 5 and the ocean is to the right of index 4. We want to find which of these indices have an ocean view.

Let's go through the steps:

Initial State:
- max_height_to_right = 0 (no buildings seen to the right yet)
- visible_indices = [] (empty list)
Step 1: Look at the rightmost building (index 4, height = 2).
- Compare heights[4] (2) with max_height_to_right (0).
- 2 > 0, so building 4 is taller than anything to its right (there is nothing to its right). It has an ocean view.
- Add index 4 to visible_indices.
- Update max_height_to_right = 2 (now the tallest seen to the right of any upcoming building is 2).
- State now: visible_indices = [4], max_height_to_right = 2.
- (Building 4 is visible.)
Step 2: Move to the next building to the left (index 3, height = 4).
- Compare heights[3] (4) with max_height_to_right (2).
- 4 > 2, so building 3 is taller than all buildings to its right (the only building to its right was height 2). It has an ocean view.
- Add index 3 to visible_indices.
- Update max_height_to_right = 4 (the tallest to the right is now 4).
- State: visible_indices = [4, 3], max_height_to_right = 4.
- (Buildings 3 and 4 are visible so far.)
Step 3: Move to index 2 (height = 8).
- Compare heights[2] (8) with max_height_to_right (4).
- 8 > 4, so building 2 is taller than everything to its right. It has an ocean view.
- Add index 2 to visible_indices.
- Update max_height_to_right = 8.
- State: visible_indices = [4, 3, 2], max_height_to_right = 8.
- (Buildings 2, 3, 4 are visible so far.)
Step 4: Move to index 1 (height = 3).
- Compare heights[1] (3) with max_height_to_right (8).
- 3 > 8 is false (3 is not greater than 8). So building 1 is not taller than the max height to its right. In fact, there’s a building (index 2 with height 8) to its right that is taller, which blocks the view.
- Do not add index 1.
- max_height_to_right stays 8 (since 3 did not change it).
- State: visible_indices = [4, 3, 2], max_height_to_right = 8.
- (Building 1 is not visible; buildings 2, 3, 4 remain the visible ones identified so far.)
Step 5: Move to index 0 (height = 5).
- Compare heights[0] (5) with max_height_to_right (8).
- 5 > 8 is false. Building 0 is not taller than the tallest building to its right (index 2 with height 8 is to its right). So building 0’s view is blocked by building 2.
- Do not add index 0.
- max_height_to_right remains 8.
- Final state: visible_indices = [4, 3, 2] (in reverse order).
Completion: We have finished the loop. The visible_indices list currently has [4, 3, 2], which corresponds to buildings at indices 2, 3, and 4 (just stored in reverse order). Now we reverse this list to get the indices in ascending order: [2, 3, 4].

Thus, for heights = [5, 3, 8, 4, 2], the buildings at indices 2, 3, and 4 have ocean views. We can double-check:

Building 2 (height 8) — taller than 4 and 2 to its right, so yes.
Building 3 (height 4) — taller than 2 to its right, so yes.
Building 4 (height 2) — last building, so yes. Building 0 was blocked by building 2, and building 1 was also blocked by building 2. The step-by-step matches our algorithm’s decisions.

Visualizing it another way: if you draw a horizontal line representing the ocean horizon to the right, buildings 2, 3, 4 stick out above any building to their right, whereas buildings 0 and 1 are overshadowed by building 2's height. The process of updating max_height_to_right encapsulates that comparison in a simple way.

Common Mistakes

Beginners might run into a few pitfalls with this problem. Here are some common mistakes and misunderstandings to watch out for:

Traversing from the wrong direction: A frequent mistake is to try scanning from the leftmost building forward. It’s more complicated to determine if a building has a taller one somewhere to its right when you haven’t looked at the right side yet. Scanning from the right (ocean side) is much simpler. Failing to iterate from the correct side can lead to complex logic or missed cases. Remember, the building at the ocean end is the starting point because it’s inherently visible.
Not updating or using the maximum correctly: When using the right-to-left method, you must update the max_height_to_right as you go. Forgetting to update this after processing a building will lead to incorrect comparisons for the next buildings. For example, if you don’t update the max, you might incorrectly mark a shorter building as visible when a taller building to its right was already encountered.
Using incorrect comparison (>= instead of >): The problem specifies that a building to the right must be smaller to not obstruct the view. If you mistakenly use >= in your comparison (thinking a building of equal height doesn’t block), you will end up incorrectly including buildings that have an equal-height neighbor to the right. Equal height is supposed to block the view! Make sure your condition is strict > (greater than), not >=. (Example: in [2, 2], the first building should not be visible because the second building is equal height, not shorter.)
Forgetting to reverse the result order: If you collect visible buildings starting from the right side, you will likely have the indices in a right-to-left order. Many beginners forget the final step of reversing this list (or otherwise outputting it in sorted order). The problem explicitly asks for indices sorted in increasing order, so forgetting to reverse or sort will lead to the output being in the wrong order (e.g., [3, 2, 0] instead of [0, 2, 3]).
Off-by-one errors in loops: When implementing the loop from right to left, be careful with your indices. A common error is to start at the last index correctly but then use a loop condition that doesn’t go all the way to index 0, or to misuse range boundaries. For instance, in Python, doing for i in range(len(heights), 0, -1) is wrong because it will start at len(heights) (which is an out-of-bounds index) and end at 1. The correct range should start at len(heights) - 1 and go down to 0 inclusive. In other languages, ensure you include index 0 in your loop.
Not considering equal heights in block logic: This is related to the comparison mistake above. If you treat equal height as not blocking, you will get it wrong. Always double-check the problem statement regarding whether equal heights block the view (in this problem they do block, since the requirement is "strictly smaller to the right").

By keeping these points in mind, you can avoid the common errors. It often helps to test your logic on small cases (including edge cases) to ensure your loop and conditions are correct.

Edge Cases

It’s important to consider edge cases to ensure the solution handles all scenarios:

Single Building: If there is only one building (heights has length 1), that building can always see the ocean (since there are no buildings to its right). The output should be [0] for a single building input. Make sure your code handles an array of size 1 correctly (it should, in both brute force and optimized approaches).
All Buildings Same Height: For example heights = [7, 7, 7, 7]. Only the last building should be visible because every other building has another of equal height to its right blocking it. The result should be [3] (if there are 4 buildings). This tests that your comparison is using strictly greater than. In a brute force check, each building except the last finds an equal-height neighbor to the right and thus is disqualified. In the optimized approach, max_height_to_right will catch this scenario (it will not be exceeded by an equal height).
Strictly Increasing Heights (from left to right): e.g. [1, 2, 3, 4, 5]. Here the tallest building is at the rightmost end. Only that rightmost building can see the ocean, because every building before it has a taller one to its right. Expected output would be the last index only. This scenario ensures that the algorithm correctly identifies that all the left ones are blocked.
Strictly Decreasing Heights: e.g. [5, 4, 3, 2, 1]. Every building is taller than those to its right, so every index should be in the output. This is a best-case for the optimized algorithm (each new building becomes the new max height to the right). It’s a good test to see that the algorithm indeed can return a large list of indices and that it properly includes the first building as well.
Random Heights with Plateaus: Consider something like [4, 2, 2, 3, 1]. In this case:
- Index 0 (height 4) is visible? Check to the right: there are smaller values and also a smaller or equal? Actually 2 and 2 and 3 and 1 are to the right; the tallest to the right is 3 which is smaller than 4, so index 0 is visible.
- Index 1 (height 2) has to its right another 2 at index 2 and some taller (3 at index 3), so it’s blocked by index 3.
- Index 2 (height 2) has to its right a taller 3, so blocked.
- Index 3 (height 3) has to its right a 1 (smaller), so visible.
- Index 4 (height 1) last, visible. Output should be [0, 3, 4]. This tests handling of equal heights in the middle and ensuring they block appropriately. (Index 1 was blocked by 3; index 2 was also blocked by 3, even though index 1 was equal height, index 2 still sees index 3.)
Large Inputs: While not a “case” in terms of different configuration, it’s important that your solution can handle the maximum array length (100,000). The optimized approach will handle this in a reasonable time, whereas the brute force would not. There should be no recursion or anything that could cause stack overflow on large input. Also, if implementing in a language like Java or C++, using an iterative loop is fine. In Python, an iterative loop is also fine here. Just ensure no super-linear complexity behaviors.

By considering these edge cases:

Single element,
All equal heights,
Monotonic increasing,
Monotonic decreasing,
Mixed with some equal values,
Maximum size input,

you can be confident the solution works for all scenarios the problem may throw at you.

This problem is essentially about finding all elements in an array that are “leaders” in terms of being greater than all elements to their right. There are some classic variations and related problems that you can practice to strengthen your understanding:

Leaders in an Array: This is a well-known problem in programming interviews. An element is called a “leader” if it is greater than all elements to its right. It’s exactly the same concept as the ocean view problem but framed generally. The typical solution is the same right-to-left scan we used here. If you enjoyed this problem, try implementing it where you return the actual leader values instead of indices. (For the above example [4,2,3,1], the leaders would be the heights [4,3,1].)
Sunset Views (From the East or West): A variation often described in coding interviews or exercises involves buildings and the sunset. If the sun sets on the west side, it’s analogous to the ocean on the right side scenario we just solved (assuming west corresponds to the right end of the list). If the sun sets on the east side (left side), you’d find which buildings can see the sunset by scanning from the leftmost side. The approach is symmetrical: you would traverse left-to-right keeping track of the maximum height to the left. Some platforms have this as “sunset views” problem using a stack to simulate viewing from one side.
Next Greater Element: While not the same goal, the pattern of scanning and using a stack is related. In the Next Greater Element problem, for each element you want to find the next element to its right that is greater. It commonly uses a decreasing monotonic stack. If you want to explore the stack approach more, look into problems like LeetCode 496. Next Greater Element I, or LeetCode 739. Daily Temperatures, where the monotonic stack strategy is applied. Those will give you practice in scanning from one side and using a stack to efficiently find relationships between elements.
View from Both Sides (Two-sided views): Think about a scenario where a building can see the ocean if either left side or right side has no taller buildings in between. This would combine two directions. While not a LeetCode problem to my knowledge, it’s an interesting twist: essentially you’d be finding both leaders from the left and right.
Trapping Rain Water: This is a different problem (LeetCode 42) involving heights of bars where you have to find trapped water between buildings. It’s not directly the same, but it uses a concept of knowing max heights to the left and right of every index (to determine water level). The way of scanning from both ends or precomputing max-to-right arrays is related in terms of technique (maintaining knowledge of extremes to one side). Solving it can give more insight on manipulating height arrays with left/right scans.