Online Stock Span - Practice Coding Problems

Online Stock Span - Problem

Design a Real-Time Stock Span Calculator

You're building a financial analytics tool that needs to calculate the stock span for each day's trading data in real-time. The span of a stock's price on any given day is defined as the maximum number of consecutive days (including today and going backward) for which the stock price was less than or equal to today's price.

Problem: Implement a StockSpanner class that processes daily stock prices one by one and returns the span for each day.

Example walkthrough:
• Day 1: Price = 100, Span = 1 (only today)
• Day 2: Price = 80, Span = 1 (80 ≤ 80, but 80 > 100 from day 1)
• Day 3: Price = 60, Span = 1 (similar logic)
• Day 4: Price = 70, Span = 2 (70 ≤ 70 for day 4, and 70 > 60 for day 3)
• Day 5: Price = 110, Span = 5 (110 ≥ all previous prices)

Key Challenge: Process prices in a streaming fashion - you can't see future prices, only past ones!

Input & Output

example_1.py — Basic Usage

$ Input: ["StockSpanner", "next", "next", "next", "next", "next", "next", "next"] [[], [100], [80], [60], [70], [60], [75], [85]]

› Output: [null, 1, 1, 1, 2, 1, 4, 6]

💡 Note: Day 1: price=100, span=1 (only current day). Day 2: price=80, span=1 (80 < 100). Day 3: price=60, span=1 (60 < 80). Day 4: price=70, span=2 (70≥60 for 1 day + current day). Day 5: price=60, span=1 (60 < 70). Day 6: price=75, span=4 (75≥60,60,70,current = 4 days). Day 7: price=85, span=6 (85≥75,60,70,60,current + 80 day = 6 days).

example_2.py — Increasing Prices

$ Input: ["StockSpanner", "next", "next", "next", "next"] [[], [31], [41], [48], [59]]

› Output: [null, 1, 2, 3, 4]

💡 Note: With strictly increasing prices, each day's span includes all previous days: 31(span=1), 41≥31(span=2), 48≥41,31(span=3), 59≥48,41,31(span=4).

example_3.py — Decreasing Prices

$ Input: ["StockSpanner", "next", "next", "next", "next"] [[], [100], [90], [80], [70]]

› Output: [null, 1, 1, 1, 1]

💡 Note: With strictly decreasing prices, each day's span is always 1 because no previous day has a price ≤ current day's price.

Constraints

1 ≤ price ≤ 10⁵
At most 10⁴ calls will be made to next
All prices are positive integers
The StockSpanner object will be instantiated and called as such: obj = StockSpanner(), param_1 = obj.next(price)

Visualization

Tap to expand

Understanding the Visualization

Maintain Decreasing Stack

Keep stack of (price, span) pairs in decreasing order of prices

Process New Price

When new price arrives, pop all stack elements with price ≤ current price

Calculate Span

Sum the spans of all popped elements plus 1 for current day

Update Stack

Push (current_price, calculated_span) to maintain monotonic property

Key Takeaway

🎯 Key Insight: Just like taller mountain peaks block the view to shorter peaks behind them, higher stock prices make lower previous prices irrelevant for future span calculations. The monotonic stack efficiently maintains only the 'significant' peaks!

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 B Bloomberg 6

The optimal solution uses a monotonic decreasing stack to achieve O(1) amortized time complexity. The key insight is that we only need to track 'significant' prices that could limit future spans. When a new price arrives, we pop all smaller/equal prices from the stack and sum their spans, then push the new price with its calculated span.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Scan for Each Query)	O(n²)	O(n)	For each new price, scan backwards through all previous prices until finding a higher one
Monotonic Stack (Optimal)	O(n)	O(n)	Use a monotonic decreasing stack to efficiently track previous higher prices

Brute Force (Linear Scan for Each Query) — Algorithm Steps

Store each incoming price in a list/array
For each new price query, start from the current day
Scan backwards day by day while price[i] <= current_price
Stop when we find a price > current_price or reach the beginning
Return the count of days we scanned

Visualization

Tap to expand

Step-by-Step Walkthrough

Add New Price

Store the new price in our array

Start Scanning

Begin from the previous day and scan backwards

Count Valid Days

Count consecutive days where price ≤ current price

Stop at Higher Price

Stop when we find a price > current price

Code -

solution.c — C

typedef struct {
    int* prices;
    int size;
    int capacity;
} StockSpanner;

StockSpanner* stockSpannerCreate() {
    StockSpanner* obj = (StockSpanner*)malloc(sizeof(StockSpanner));
    obj->capacity = 1000;
    obj->prices = (int*)malloc(obj->capacity * sizeof(int));
    obj->size = 0;
    return obj;
}

int stockSpannerNext(StockSpanner* obj, int price) {
    obj->prices[obj->size++] = price;
    int span = 1;
    
    // Scan backwards from the previous day
    for (int i = obj->size - 2; i >= 0; i--) {
        if (obj->prices[i] <= price) {
            span++;
        } else {
            break;
        }
    }
    
    return span;
}

void stockSpannerFree(StockSpanner* obj) {
    free(obj->prices);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For n prices, each query takes O(n) time in worst case, giving O(n²) total

⚠ Quadratic Growth

Space Complexity

O(n)

Stores all n historical prices in an array

⚡ Linearithmic Space

98.5K Views

Medium-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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Linear Scan for Each Query) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler