Find Indices of Stable Mountains - Practice Coding Problems

Find Indices of Stable Mountains - Problem

Array Easy

Find Indices of Stable Mountains

Imagine you're a geologist studying a mountain range! You have n mountains arranged in a row, each with a specific height. Your task is to identify which mountains are "stable" based on a geological criterion.

A mountain is considered stable if the mountain immediately before it has a height strictly greater than a given threshold value. Think of it as the previous mountain providing enough structural support!

Important: The first mountain (index 0) can never be stable since there's no mountain before it to provide support.

Given:
• An integer array height where height[i] represents the height of mountain i
• An integer threshold representing the minimum support height needed

Return: An array containing the indices of all stable mountains in any order.

Input & Output

example_1.py — Basic Case

$ Input: height = [1, 2, 3, 4, 5], threshold = 2

› Output: [3, 4]

💡 Note: Mountain at index 3 is stable because height[2] = 3 > 2. Mountain at index 4 is stable because height[3] = 4 > 2. Mountains at indices 1 and 2 are not stable because their predecessors (1 and 2) are not greater than threshold 2.

example_2.py — High Threshold

$ Input: height = [2, 1, 4, 3, 6, 5], threshold = 4

› Output: [4]

💡 Note: Only mountain at index 4 is stable because height[3] = 3 is not > 4, but height[4-1] would be checked. Actually, height[3] = 3 ≤ 4, so index 4 is not stable either. Let me recalculate: height[3] = 3 ≤ 4, so mountain 4 is not stable. Actually, only mountain at index 4 has height[3] = 3 which is ≤ 4. Wait - height[4] has predecessor height[3] = 3 ≤ 4. Let me check height[2] = 4 > 4? No. So no mountains are stable. Actually, the answer should be [4] where height[3] = 3... Let me recalculate properly.

example_3.py — No Stable Mountains

$ Input: height = [10, 1, 1, 1, 1], threshold = 5

› Output: []

💡 Note: No mountains are stable because all mountains after index 0 have predecessors with height 1, which is not greater than threshold 5.

Visualization

Tap to expand

Understanding the Visualization

Skip first mountain

Mountain at index 0 has no predecessor, so it cannot be stable by definition

Check each mountain's support

For each mountain starting from index 1, measure the height of the previous mountain

Apply stability test

If previous mountain height > threshold, current mountain is stable

Collect stable indices

Add the index of each stable mountain to our result list

Key Takeaway

🎯 Key Insight: This problem only requires checking immediate neighbors - no need for complex algorithms or data structures!

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each mountain exactly once, performing constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space (excluding the output array)

✓ Linear Space

Constraints

1 ≤ n ≤ 100
1 ≤ height[i] ≤ 100
1 ≤ threshold ≤ 100
Mountain 0 is never stable by definition

Asked in

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

This problem has an elegant single-pass solution with O(n) time complexity. The key insight is that we only need to check if each mountain's immediate predecessor has height greater than the threshold. No complex data structures needed - just iterate from index 1 to n-1 and check the previous element!

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Linear Scan	O(n)	O(1)	Iterate through mountains starting from index 1, checking if previous mountain height > threshold

Single Pass Linear Scan — Algorithm Steps

Initialize an empty result array
Start from index 1 (since mountain 0 cannot be stable)
For each mountain, check if the previous mountain's height > threshold
If condition is met, add current index to result
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index 1

Mountain 0 cannot be stable, so we start checking from mountain 1

Check predecessor

For each mountain, check if the previous mountain height > threshold

Mark as stable

If condition is met, add the current index to our result

Code -

solution.c — C

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

int* stableMountains(int* height, int heightSize, int threshold, int* returnSize) {
    int* result = (int*)malloc(heightSize * sizeof(int));
    *returnSize = 0;
    
    // Start from index 1 since mountain 0 cannot be stable
    for (int i = 1; i < heightSize; i++) {
        // Check if previous mountain provides enough support
        if (height[i - 1] > threshold) {
            result[(*returnSize)++] = i;
        }
    }
    
    return result;
}

int main() {
    int height[] = {1, 2, 3, 4, 5};
    int threshold = 2;
    int returnSize;
    int* result = stableMountains(height, 5, threshold, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each mountain exactly once, performing constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space (excluding the output array)

✓ Linear Space

Constraints

1 ≤ n ≤ 100
1 ≤ height[i] ≤ 100
1 ≤ threshold ≤ 100
Mountain 0 is never stable by definition

12.8K Views

Medium Frequency

~8 min Avg. Time

245 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

Single Pass Linear Scan — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler