Stock Price Fluctuation - Practice Coding Problems

Stock Price Fluctuation - Problem

Stock Price Fluctuation Tracker

You're building a real-time stock monitoring system that handles chaotic market data. In the fast-paced world of trading, price updates arrive out of order and sometimes contain errors that need correction.

Your system receives a stream of records, each containing a timestamp and corresponding stock price. However:
• Records don't arrive chronologically
• Multiple records may have the same timestamp (corrections)
• Later records with the same timestamp override earlier ones

Design a StockPrice class that supports:
• update(timestamp, price) - Update/correct price at given timestamp
• current() - Get the most recent price (latest timestamp)
• maximum() - Get the highest price across all current records
• minimum() - Get the lowest price across all current records

Example: If you receive prices at timestamps [3,1,2,3] with values [100,60,80,110], the final state should show timestamp 3 has price 110 (corrected), and current() returns 110 since timestamp 3 is latest.

Input & Output

example_1.py — Basic Operations

$ Input: ["StockPrice", "update", "update", "current", "maximum", "update", "maximum", "update", "minimum"] [[], [1, 10], [2, 5], [], [], [1, 3], [], [4, 2], []]

› Output: [null, null, null, 5, 10, null, 5, null, 2]

💡 Note: StockPrice stockPrice = new StockPrice(); stockPrice.update(1, 10); // Timestamps are [1] with prices [10]. stockPrice.update(2, 5); // Timestamps are [1,2] with prices [10,5]. stockPrice.current(); // return 5, the latest timestamp is 2 with price 5. stockPrice.maximum(); // return 10, the maximum price is 10 at timestamp 1. stockPrice.update(1, 3); // The previous timestamp 1 had the wrong price, corrected to 3. stockPrice.maximum(); // return 5, the maximum price is 5 after the correction. stockPrice.update(4, 2); // Timestamps are [1,2,4] with prices [3,5,2]. stockPrice.minimum(); // return 2, the minimum price is 2 at timestamp 4.

example_2.py — Price Corrections

$ Input: ["StockPrice", "update", "update", "update", "maximum", "update", "maximum", "minimum"] [[], [1, 100], [2, 200], [3, 50], [], [2, 300], [], []]

› Output: [null, null, null, null, 200, null, 300, 50]

💡 Note: Multiple price updates including correction at timestamp 2 from 200 to 300. The maximum changes from 200 to 300, while minimum remains 50.

example_3.py — Edge Case: Single Update

$ Input: ["StockPrice", "update", "current", "maximum", "minimum"] [[], [1, 42], [], [], []]

› Output: [null, null, 42, 42, 42]

💡 Note: With only one price record, current, maximum, and minimum all return the same value.

Constraints

1 ≤ timestamp, price ≤ 10⁹
At most 10⁵ calls will be made in total to update, current, maximum, and minimum
current, maximum, and minimum will be called only after update has been called at least once

Visualization

Tap to expand

current(): 110maximum(): 110minimum(): 60All O(log n) or better!🎯 Key Insight: Lazy DeletionDon't remove outdated heap entries immediately.Validate during queries by checking current hash map values!

Understanding the Visualization

Chaotic Updates

Price updates arrive out of order and corrections overwrite previous values

Hash Map Storage

Use hash map for O(1) price lookups and updates, tracking latest timestamp

Heap Management

Maintain max and min heaps for efficient extreme value queries

Lazy Validation

When querying heaps, validate top entries against current hash map values

Key Takeaway

🎯 Key Insight: Using heaps with lazy deletion allows us to handle price corrections efficiently - we validate heap entries against the hash map only when needed, achieving optimal time complexity for all operations.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28 B Bloomberg 25

The optimal solution uses a hash map for O(1) price updates and a current timestamp tracker, combined with max and min heaps for efficient maximum/minimum queries. The key insight is using lazy deletion - when prices are corrected, we don't remove old entries from heaps immediately, but validate them during queries by checking against the current hash map values.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n)	O(n)	Store all prices and scan linearly for max/min operations
Hash Map + Heaps (Optimal)	O(log n)	O(n)	Use hash map for updates and heaps with lazy deletion for efficient max/min queries

Brute Force (Linear Search) — Algorithm Steps

Store all timestamp-price mappings in a hash map
Track the latest timestamp separately for current()
For max/min operations, iterate through all stored prices
Return the maximum or minimum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Prices

Keep timestamp-price pairs in hash map

Track Latest

Maintain latest timestamp for current()

Linear Search

Scan all prices for maximum/minimum

Code -

solution.c — C

typedef struct {
    int* timestamps;
    int* prices;
    int size;
    int capacity;
    int latestTimestamp;
} StockPrice;

StockPrice* stockPriceCreate() {
    StockPrice* obj = malloc(sizeof(StockPrice));
    obj->capacity = 1000;
    obj->timestamps = malloc(obj->capacity * sizeof(int));
    obj->prices = malloc(obj->capacity * sizeof(int));
    obj->size = 0;
    obj->latestTimestamp = 0;
    return obj;
}

void stockPriceUpdate(StockPrice* obj, int timestamp, int price) {
    for (int i = 0; i < obj->size; i++) {
        if (obj->timestamps[i] == timestamp) {
            obj->prices[i] = price;
            if (timestamp > obj->latestTimestamp) {
                obj->latestTimestamp = timestamp;
            }
            return;
        }
    }
    obj->timestamps[obj->size] = timestamp;
    obj->prices[obj->size] = price;
    obj->size++;
    if (timestamp > obj->latestTimestamp) {
        obj->latestTimestamp = timestamp;
    }
}

int stockPriceCurrent(StockPrice* obj) {
    for (int i = 0; i < obj->size; i++) {
        if (obj->timestamps[i] == obj->latestTimestamp) {
            return obj->prices[i];
        }
    }
    return -1;
}

int stockPriceMaximum(StockPrice* obj) {
    int maxPrice = obj->prices[0];
    for (int i = 1; i < obj->size; i++) {
        if (obj->prices[i] > maxPrice) {
            maxPrice = obj->prices[i];
        }
    }
    return maxPrice;
}

int stockPriceMinimum(StockPrice* obj) {
    int minPrice = obj->prices[0];
    for (int i = 1; i < obj->size; i++) {
        if (obj->prices[i] < minPrice) {
            minPrice = obj->prices[i];
        }
    }
    return minPrice;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Update and current are O(1), but maximum and minimum require scanning all n prices

✓ Linear Growth

Space Complexity

O(n)

Store one price per unique timestamp in hash map

⚡ Linearithmic Space

47.0K Views

High Frequency

~25 min Avg. Time

1.6K 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 Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler