739. Daily Temperatures

Problem

Given an array of integers temperatures represents the daily temperatures, return an array answer such that answer[i] is the number of days you have to wait after the ith day to get a warmer temperature. If there is no future day for which this is possible, keep answer[i] == 0 instead.

  Example 1:

Input: temperatures = [73,74,75,71,69,72,76,73]
Output: [1,1,4,2,1,1,0,0]

Example 2:

Input: temperatures = [30,40,50,60]
Output: [1,1,1,0]

Example 3:

Input: temperatures = [30,60,90]
Output: [1,1,0]

  Constraints:

• 1 <=&nbsp;temperatures.length <= 10^5

• 30 <=&nbsp;temperatures[i] <= 100

Solution (Java)

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int[] sol = new int[temperatures.length];
        sol[temperatures.length - 1] = 0;
        for (int i = sol.length - 2; i >= 0; i--) {
            int j = i + 1;
            while (j <= sol.length) {
                if (temperatures[i] < temperatures[j]) {
                    sol[i] = j - i;
                    break;
                } else {
                    if (sol[j] == 0) {
                        break;
                    }
                    j = j + sol[j];
                }
            }
        }
        return sol;
    }
}

Solution (Javascript)

/**
 * @param {number[]} temperatures
 * @return {number[]}
 */
var dailyTemperatures = function(temperatures) {
    let len = temperatures.length
    let result = new Array(len).fill(0) // fill the all result values to 0

    let stack = [], poppedValue
    for(let i = 0; i < len - 1; i++){

        stack.push(i) // push the index of current temperature

        /* 
        * checking if next day tempearature is greater than the last stack index
        * if found popped the last index from the stack
        * then update the result array with the popped index
        * repeat the process until stack is empty
        */
        while(stack.length && temperatures[stack[stack.length-1]] < temperatures[i+1]){
            poppedValue = stack.pop()
            result[poppedValue] = i + 1 - poppedValue
        }
    }
    return result
};

Explain:

nope.

Complexity:

• Time complexity : O(n).
• Space complexity : O(n).