Daily Temperatures solution and explanation

def dailyTemperatures(temperatures):
    answer = [0] * len(temperatures)
    stack = []  # stores indices
    for i, temp in enumerate(temperatures):
        while stack and temperatures[stack[-1]] < temp:
            prev_index = stack.pop()
            answer[prev_index] = i - prev_index
        stack.append(i)
    return answer

#include <vector>
#include <stack>
using namespace std;

vector<int> dailyTemperatures(vector<int>& temperatures) {
    vector<int> answer(temperatures.size(), 0);
    stack<int> s; // Stores indices
    for (int i = 0; i < temperatures.size(); ++i) {
        while (!s.empty() && temperatures[i] > temperatures[s.top()]) {
            int prev_index = s.top();
            s.pop();
            answer[prev_index] = i - prev_index;
        }
        s.push(i);
    }
    return answer;
}

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int n = temperatures.length;
        int[] answer = new int[n];
        int[] next = new int[101];
        Arrays.fill(next, Integer.MAX_VALUE);
        for (int i = n - 1; i >= 0; i--) {
            int warmerIndex = Integer.MAX_VALUE;
            for (int t = temperatures[i] + 1; t <= 100; t++) {
                warmerIndex = Math.min(warmerIndex, next[t]);
            }
            if (warmerIndex < Integer.MAX_VALUE) {
                answer[i] = warmerIndex - i;
            }
            next[temperatures[i]] = i;
        }
        return answer;
    }
}

function dailyTemperatures(temperatures) {
    const n = temperatures.length;
    const answer = Array(n).fill(0);
    const next = Array(101).fill(Infinity);
    for (let i = n - 1; i >= 0; i--) {
        let minIndex = Infinity;
        for (let t = temperatures[i] + 1; t <= 100; t++) {
            if (next[t] < minIndex) {
                minIndex = next[t];
            }
        }
        if (minIndex < Infinity) {
            answer[i] = minIndex - i;
        }
        next[temperatures[i]] = i;
    }
    return answer;
}

function dailyTemperatures(temperatures: number[]): number[] {
    const n = temperatures.length;
    const ans: number[] = Array(n).fill(0);
    const stk: number[] = [];
    for (let i = n - 1; ~i; --i) {
        while (stk.length && temperatures[stk.at(-1)!] <= temperatures[i]) {
            stk.pop();
        }
        if (stk.length) {
            ans[i] = stk.at(-1)! - i;
        }
        stk.push(i);
    }
    return ans;
}

func dailyTemperatures(temperatures []int) []int {
	n := len(temperatures)
	ans := make([]int, n)
	stk := []int{}
	for i := n - 1; i >= 0; i-- {
		for len(stk) > 0 && temperatures[stk[len(stk)-1]] <= temperatures[i] {
			stk = stk[:len(stk)-1]
		}
		if len(stk) > 0 {
			ans[i] = stk[len(stk)-1] - i
		}
		stk = append(stk, i)
	}
	return ans
}

impl Solution {
    pub fn daily_temperatures(temperatures: Vec<i32>) -> Vec<i32> {
        let n = temperatures.len();
        let mut stk: Vec<usize> = Vec::new();
        let mut ans = vec![0; n];

        for i in (0..n).rev() {
            while let Some(&top) = stk.last() {
                if temperatures[top] <= temperatures[i] {
                    stk.pop();
                } else {
                    break;
                }
            }
            if let Some(&top) = stk.last() {
                ans[i] = (top - i) as i32;
            }
            stk.push(i);
        }

        ans
    }
}