Daily Temperatures - Practice Coding Problems

Daily Temperatures - Problem

Imagine you're a weather forecaster tasked with helping people plan their activities. Given an array of daily temperatures, you need to determine how many days each person must wait to experience a warmer day.

For each day i, calculate the number of days until a temperature higher than temperatures[i] occurs. If no warmer day exists in the future, return 0 for that day.

Example: If temperatures are [73, 74, 75, 71, 69, 72, 76, 73], then:

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 5 (72°): Next warmer day is day 6 (76°) → wait 1 day

This is a classic "next greater element" problem that can be solved efficiently using a monotonic stack.

Input & Output

example_1.py — Basic Temperature Sequence

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

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

💡 Note: Day 0 (73°): Day 1 has 74° → wait 1 day. Day 1 (74°): Day 2 has 75° → wait 1 day. Day 2 (75°): Day 6 has 76° → wait 4 days. Day 3 (71°): Day 5 has 72° → wait 2 days. Day 4 (69°): Day 5 has 72° → wait 1 day. Day 5 (72°): Day 6 has 76° → wait 1 day. Days 6,7: No warmer days ahead → 0.

example_2.py — Increasing Temperatures

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

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

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

example_3.py — Decreasing Temperatures

$ Input: [30,60,90]

› Output: [1,1,0]

💡 Note: Day 0 finds warmer day at index 1, day 1 finds warmer day at index 2, day 2 has no warmer future day.

Visualization

Tap to expand

Understanding the Visualization

Station Setup

Weather station initializes with empty stack and result board

Daily Reading

Each day, check if current temperature resolves any pending days in stack

Stack Maintenance

Pop resolved days, record their wait times, then add current day to pending stack

Completion

Days remaining in stack have no future warmer days (already set to 0)

Key Takeaway

🎯 Key Insight: The monotonic stack eliminates redundant comparisons by maintaining only the temperatures that could potentially be resolved by future warmer days, achieving optimal linear time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped from stack at most once, resulting in linear time

✓ Linear Growth

Space Complexity

O(n)

In worst case (decreasing temperatures), stack can contain all n elements

⚡ Linearithmic Space

Constraints

1 ≤ temperatures.length ≤ 10⁵
30 ≤ temperatures[i] ≤ 100
All temperatures are valid Fahrenheit temperatures

Asked in

a Amazon 42 G Google 38 f Meta 31 ⊞ Microsoft 28 Apple 22

The optimal solution uses a monotonic decreasing stack to efficiently track temperatures awaiting warmer days. By maintaining indices in the stack and processing each temperature exactly once, we achieve O(n) time complexity, making it much faster than the O(n²) brute force approach for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each day, scan all future days to find the next warmer temperature
Monotonic Stack (Optimal)	O(n)	O(n)	Use a decreasing monotonic stack to efficiently track temperatures waiting for warmer days

Brute Force (Nested Loops) — Algorithm Steps

Initialize result array with zeros
For each day i from 0 to n-1
For each future day j from i+1 to n-1
If temperature[j] > temperature[i], set result[i] = j-i and break
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with first temperature, prepare to scan all future days

Inner Loop

For current day, check each future day until finding warmer temperature

Record Result

When warmer day found, record the difference and move to next day

Code -

solution.c — C

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

int* dailyTemperatures(int* temperatures, int temperaturesSize, int* returnSize) {
    *returnSize = temperaturesSize;
    int* result = (int*)calloc(temperaturesSize, sizeof(int));
    
    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 input[1000];
    fgets(input, sizeof(input), stdin);
    
    int temperatures[100];
    int size = 0;
    char* token = strtok(input, "[,]\n ");
    
    while (token != NULL) {
        temperatures[size++] = atoi(token);
        token = strtok(NULL, "[,]\n ");
    }
    
    int returnSize;
    int* result = dailyTemperatures(temperatures, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(", ");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n elements, we potentially scan through all remaining n-1 elements in the worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space besides the result array

✓ Linear Space

Constraints

1 ≤ temperatures.length ≤ 10⁵
30 ≤ temperatures[i] ≤ 100
All temperatures are valid Fahrenheit temperatures

89.7K Views

High Frequency

~15 min Avg. Time

2.8K 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler