Find Indices of Stable Mountains
Source: leetcode
Difficulty: Easy
Tags: array

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** that mountain 0 is **not** stable.


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


 


**Example 1:**



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


**Output:** \[3,4]


**Explanation:**


- Mountain 3 is stable because `height[2] == 3` is greater than `threshold == 2`.
- Mountain 4 is stable because `height[3] == 4` is greater than `threshold == 2`.



**Example 2:**



**Input:** height \= \[10,1,10,1,10], threshold \= 3


**Output:** \[1,3]



**Example 3:**



**Input:** height \= \[10,1,10,1,10], threshold \= 10


**Output:** \[]



 


**Constraints:**


- `2 <= n == height.length <= 100`
- `1 <= height[i] <= 100`
- `1 <= threshold <= 100`




C++ solution:
class Solution {
public:
    vector<int> stableMountains(vector<int>& height, int threshold) {
        vector<int>res;int n = height.size();
        for(int i=1;i<n;i++){
            if(height[i-1] > threshold) res.push_back(i);
        }
        return res;
    }
};

Go solution:
func stableMountains(height []int, threshold int) []int {
	res := make([]int, 0)
	for i := 1; i < len(height); i++ {
		if height[i-1] > threshold {
			res = append(res, i)
		}
	}
    return res
}

Java solution:
class Solution {
    public List<Integer> stableMountains(int[] height, int threshold) {
        List<Integer> ans = new ArrayList<>();
        
        for (int i = 0; i < height.length - 1; i++) {
            int prv = height[i];
            if (prv > threshold) {
                ans.add(i + 1);
            }
        }
        
        return ans;
    }
}

JavaScript solution:
var stableMountains = function(height, threshold) {
    const result = []
    for(let i = 1 ; i< height.length ; i++)
        if(height[i-1] > threshold)
            result.push(i)
    return result ;
};

Python solution:
class Solution:
    def stableMountains(self, height: List[int], threshold: int) -> List[int]:
        r = []
        for i in range(1,len(height)):
            if height[i-1] > threshold:
                r.append(i)
        return r

Ruby solution:
def stable_mountains(height, threshold)
    output = []
    for i in 1..(height.length())-1 do
        if height[i-1]> threshold
            output.push(i)
        end
    end
    return output
end