Days until a warmer day

def next_warmer(temps):
    wait = [0] * len(temps)
    stack = []                         # indices of days still waiting for a warmer one
    for i, t in enumerate(temps):
        while stack and temps[stack[-1]] < t:
            j = stack.pop()
            wait[j] = i - j            # today is the first day warmer than day j
        stack.append(i)
    return wait                        # days never popped keep their 0

#include <vector>

std::vector<int> solve(const std::vector<int>& temps) {
    const int n = static_cast<int>(temps.size());
    std::vector<int> wait(n, 0), stack;     // stack holds indices still waiting
    stack.reserve(n);
    for (int i = 0; i < n; ++i) {
        while (!stack.empty() && temps[stack.back()] < temps[i]) {
            wait[stack.back()] = i - stack.back();   // first warmer day
            stack.pop_back();
        }
        stack.push_back(i);
    }
    return wait;
}

class Solution {
    public int[] nextWarmer(int[] temps) {
        int n = temps.length;
        int[] wait = new int[n];
        int[] stack = new int[n];               // indices still waiting; top is stack[top - 1]
        int top = 0;
        for (int i = 0; i < n; i++) {
            while (top > 0 && temps[stack[top - 1]] < temps[i]) {
                int j = stack[--top];
                wait[j] = i - j;                // first warmer day after j
            }
            stack[top++] = i;
        }
        return wait;
    }
}

function nextWarmer(temps) {
  const wait = new Array(temps.length).fill(0);
  const stack = [];                    // indices of days still waiting
  for (let i = 0; i < temps.length; i++) {
    while (stack.length && temps[stack[stack.length - 1]] < temps[i]) {
      const j = stack.pop();
      wait[j] = i - j;                 // today is the first warmer day after j
    }
    stack.push(i);
  }
  return wait;
}

fn solve(temps: &[i32]) -> Vec<usize> {
    let mut wait = vec![0usize; temps.len()];
    let mut stack: Vec<usize> = Vec::new();     // indices still waiting
    for i in 0..temps.len() {
        while let Some(&j) = stack.last() {
            if temps[j] >= temps[i] {
                break;
            }
            wait[j] = i - j;                    // first warmer day after j
            stack.pop();
        }
        stack.push(i);
    }
    wait
}

-- Walk from the right. The stack holds (index, temperature) for the days still in view:
-- a day hidden behind a warmer, nearer day can never be anyone's answer.
solve :: [Int] -> [Int]
solve temps = snd (foldr step ([], []) (zip [0 ..] temps))
  where
    step (i, t) (stack, out) =
      let stack' = dropWhile (\(_, u) -> u <= t) stack
          w      = case stack' of
                     ((j, _) : _) -> j - i
                     []           -> 0
      in ((i, t) : stack', w : out)