How many days in a row the price was no higher

def stock_span(prices):
    st, out = [], []
    for i, p in enumerate(prices):
        while st and prices[st[-1]] <= p:   # days hidden behind today
            st.pop()
        out.append(i - st[-1] if st else i + 1)
        st.append(i)
    return out

#include <vector>

std::vector<int> solve(const std::vector<int>& prices) {
    std::vector<int> st, out;
    for (int i = 0; i < (int)prices.size(); ++i) {
        while (!st.empty() && prices[st.back()] <= prices[i]) st.pop_back();   // days hidden behind today
        out.push_back(st.empty() ? i + 1 : i - st.back());
        st.push_back(i);
    }
    return out;
}

class Solution {
    public int[] stockSpan(int[] prices) {
        int n = prices.length, top = -1;
        int[] st = new int[n], out = new int[n];
        for (int i = 0; i < n; i++) {
            while (top >= 0 && prices[st[top]] <= prices[i]) top--;   // days hidden behind today
            out[i] = top >= 0 ? i - st[top] : i + 1;
            st[++top] = i;
        }
        return out;
    }
}

function stockSpan(prices) {
  const st = [], out = [];
  prices.forEach((p, i) => {
    while (st.length && prices[st[st.length - 1]] <= p) st.pop();   // days hidden behind today
    out.push(st.length ? i - st[st.length - 1] : i + 1);
    st.push(i);
  });
  return out;
}

fn solve(prices: &[i64]) -> Vec<i64> {
    let mut st: Vec<usize> = Vec::new();
    let mut out = Vec::with_capacity(prices.len());
    for (i, &p) in prices.iter().enumerate() {
        while let Some(&t) = st.last() {
            if prices[t] <= p { st.pop(); } else { break; }   // days hidden behind today
        }
        out.push(match st.last() { Some(&t) => (i - t) as i64, None => i as i64 + 1 });
        st.push(i);
    }
    out
}

-- The stack holds (index, price) pairs, top at the head.
solve :: [Int] -> [Int]
solve prices = go [] (zip [0 ..] prices)
  where
    go _ [] = []
    go st ((i, p) : rest) =
      let st' = dropWhile (\(_, q) -> q <= p) st     -- days hidden behind today
          s = case st' of
                ((j, _) : _) -> i - j
                []           -> i + 1
      in s : go ((i, p) : st') rest