Temperature Tracker - Problem

Given an array of daily temperatures, return an array where each element represents the number of days you have to wait until a warmer temperature arrives. If there is no future day with a warmer temperature, use 0 instead.

Use a monotonic stack approach to solve this efficiently. The stack should maintain temperatures in decreasing order and help track indices of days waiting for warmer weather.

Example: For temperatures [73, 74, 75, 71, 69, 72, 76, 73], the output should be [1, 1, 4, 2, 1, 1, 0, 0] because day 0 (73°) finds a warmer day after 1 day (74°), day 2 (75°) finds a warmer day after 4 days (76°), and so on.

Input & Output

Example 1 — Basic Temperature Sequence

$ Input: temperatures = [73, 74, 75, 71, 69, 72, 76, 73]

› Output: [1, 1, 4, 2, 1, 1, 0, 0]

💡 Note: Day 0 (73°): next warmer day is day 1 (74°) → wait 1 day. Day 1 (74°): next warmer day is day 2 (75°) → wait 1 day. Day 2 (75°): next warmer day is day 6 (76°) → wait 4 days. Day 6 and 7 have no warmer days ahead → 0.

Example 2 — Increasing Sequence

$ Input: temperatures = [30, 40, 50, 60]

› Output: [1, 1, 1, 0]

💡 Note: Each day finds a warmer day immediately next, except the last day which has no future days.

Example 3 — Decreasing Sequence

$ Input: temperatures = [30, 60, 90]

› Output: [1, 1, 0]

💡 Note: Day 0 finds warmer day 1, day 1 finds warmer day 2, day 2 has no warmer days ahead.

Constraints

1 ≤ temperatures.length ≤ 10⁵
30 ≤ temperatures[i] ≤ 100

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 Apple 25

The key insight is using a monotonic decreasing stack to efficiently track days waiting for warmer weather. Instead of checking each day forward individually, we process days and resolve multiple waiting days whenever a warmer temperature arrives. Best approach is the monotonic stack with Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Check Every Future Day

⏱️ Time: O(n²) Space: O(1)

For each day i, iterate through all subsequent days j (where j > i) to find the first day with a higher temperature. Count the days between them.

Monotonic Stack - Optimal Solution

⏱️ Time: O(n) Space: O(n)

Maintain a stack of indices with decreasing temperatures. When a warmer day arrives, pop all colder days from the stack and calculate their wait times.

Brute Force - Check Every Future Day — Algorithm Steps

For each day i from 0 to n-1
Search days i+1, i+2, ... until finding higher temperature
Record the number of days waited, or 0 if none found

Visualization

Tap to expand

Step-by-Step Walkthrough

Day 0 (73°)

Check day 1: 74° > 73° ✓ → wait 1 day

Day 1 (74°)

Check day 2: 75° > 74° ✓ → wait 1 day

Day 2 (75°)

Check days 3,4,5,6: finally 76° > 75° ✓ → wait 4 days

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int* solution(int* temperatures, int temperaturesSize, int* returnSize) {
    int* result = (int*)calloc(temperaturesSize, sizeof(int));
    *returnSize = temperaturesSize;
    
    for (int i = 0; i < temperaturesSize; i++) {
        for (int j = i + 1; j < temperaturesSize; j++) {
            if (temperatures[j] > temperatures[i]) {
                result[i] = j - i;
                break;
            }
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array
    int temperatures[1000];
    int size = 0;
    char* ptr = line + 1; // Skip opening bracket
    while (*ptr && *ptr != ']') {
        temperatures[size++] = atoi(ptr);
        while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
        if (*ptr == ',') ptr++;
    }
    
    int returnSize;
    int* result = solution(temperatures, size, &returnSize);
    
    // Print result
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops where each day potentially checks all future days

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for iteration

⚡ Linearithmic Space

89.0K Views

High Frequency

~15 min Avg. Time

2.4K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Temperature Tracker - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check Every Future Day — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler