Find Indices of Stable Mountains - Practice Coding Problems

Find Indices of Stable Mountains - Problem

Array Easy

There are n mountains in a row, and each mountain has a height. You are given an integer array height where height[i] represents the height of mountain i, and an integer threshold.

A mountain is called stable if the mountain just before it (if it exists) has a height strictly greater than threshold.

Note: Mountain 0 is not stable.

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

Input & Output

Example 1 — Basic Case

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

› Output: [3,4]

💡 Note: Mountain 3 is stable because height[2] = 3 > 2. Mountain 4 is stable because height[3] = 4 > 2. Mountains 0,1,2 are not stable.

Example 2 — No Stable Mountains

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

› Output: []

💡 Note: No mountain is stable because height[0] = 2 ≤ 5 and height[1] = 1 ≤ 5.

Example 3 — All Mountains Stable

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

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

💡 Note: Mountains 1,2,3,4 are all stable because their previous mountains have height 10 > 3.

Constraints

1 ≤ height.length ≤ 100
1 ≤ height[i] ≤ 100
1 ≤ threshold ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Input

Array of mountain heights and threshold value

Process

Check each mountain's previous height against threshold

Output

Array of indices where mountains are stable

Key Takeaway

🎯 Key Insight: A mountain is stable if and only if its immediate predecessor has height strictly greater than the threshold

Asked in

M Microsoft 15 A Apple 12

This problem requires a single pass through the mountain array. The key insight is that we only need to check if each mountain's predecessor exceeds the threshold. Best approach is single iteration starting from index 1. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Check	O(n)	O(1)	Iterate through mountains and check if previous mountain height exceeds threshold

Single Pass Check — Algorithm Steps

Step 1: Initialize empty result array
Step 2: Iterate from index 1 to n-1
Step 3: For each mountain, check if height[i-1] > threshold
Step 4: If true, add index i to result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from index 1

Mountain 0 cannot be stable by definition

Check previous height

Compare height[i-1] with threshold

Add stable indices

Collect indices where previous mountain is tall enough

Code -

solution.c — C

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

int* solution(int* height, int heightSize, int threshold, int* returnSize) {
    int* result = (int*)malloc(heightSize * sizeof(int));
    int count = 0;
    
    for (int i = 1; i < heightSize; i++) {
        if (height[i-1] > threshold) {
            result[count++] = i;
        }
    }
    
    *returnSize = count;
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int height[100];
    int heightSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        height[heightSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int threshold;
    scanf("%d", &threshold);
    
    int returnSize;
    int* result = solution(height, heightSize, threshold, &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 loop through all mountains once

✓ Linear Growth

Space Complexity

O(1)

Only using result array which is required output, no extra space

✓ Linear Space

8.5K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Single Pass Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler