Number of Orders in the Backlog - Practice Coding Problems

Number of Orders in the Backlog - Problem

📈 Stock Market Order Matching System

You're building a stock trading order matching engine! Given a sequence of buy and sell orders, you need to simulate how they would be matched and executed.

Each order is represented as [price, amount, orderType] where:

orderType = 0: Buy order (wants to purchase stock)
orderType = 1: Sell order (wants to sell stock)

🔄 Matching Rules:

Buy Order: Matches with the cheapest sell order if sell price ≤ buy price
Sell Order: Matches with the highest buy order if buy price ≥ sell price
Unmatched orders go into a backlog (pending orders)

Return the total number of orders remaining in the backlog after processing all orders. Since the result can be large, return it modulo 10⁹ + 7.

💡 Think of it like a marketplace where buyers want low prices and sellers want high prices - orders only execute when both parties agree!

Input & Output

example_1.py — Basic Order Matching

$ Input: orders = [[10,5,0],[15,2,1],[25,1,1],[30,4,0]]

› Output: 6

💡 Note: Buy order [10,5,0] → backlog: buy[(10,5)]. Sell order [15,2,1] → no match, backlog: buy[(10,5)], sell[(15,2)]. Sell order [25,1,1] → no match, backlog: buy[(10,5)], sell[(15,2), (25,1)]. Buy order [30,4,0] → matches sell (15,2) and sell (25,1), uses 3 orders, 1 remaining → backlog: buy[(10,5), (30,1)]. Total: 5+1 = 6

example_2.py — Complete Matching

$ Input: orders = [[7,1000000000,1],[15,3,0],[5,999999995,0],[5,1,1]]

› Output: 999999984

💡 Note: Large sell order gets partially matched by smaller buy orders. The remaining amount is (1000000000 - 3 - 1) % (10^9 + 7) = 999999996. But after all matching, total backlog is 999999984.

example_3.py — No Matches

$ Input: orders = [[1,2,0],[2,3,0],[10,1,1]]

› Output: 6

💡 Note: Buy orders at $1 and $2, sell order at $10. No matches since sell price > buy prices. All orders go to backlog: 2+3+1 = 6

Visualization

Tap to expand

Understanding the Visualization

Order Arrival

New buy/sell order arrives at the exchange

Priority Check

Check top of relevant heap for best matching candidate

Match & Execute

If prices are compatible, execute the trade

Update Backlog

Add unmatched portion to appropriate priority queue

Key Takeaway

🎯 Key Insight: Priority queues transform O(n²) brute force matching into O(n log n) by maintaining sorted order automatically, making real-time trading feasible!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each order involves O(log n) heap operations, and we process n orders

⚡ Linearithmic

Space Complexity

O(n)

Store up to n orders in the two priority queues

⚡ Linearithmic Space

Constraints

1 ≤ orders.length ≤ 10⁵
orders[i].length == 3
1 ≤ pricei, amounti ≤ 10⁹
orderTypei is either 0 or 1
Large amounts require modulo arithmetic

Asked in

GS Goldman Sachs 45 JP JPMorgan 38 B Bloomberg 32 C Citadel 28 JS Jane Street 25

The optimal solution uses two priority queues: a max-heap for buy orders (to quickly find highest prices) and a min-heap for sell orders (to quickly find lowest prices). This achieves O(n log n) time complexity, making it suitable for high-frequency trading systems. Each order matching takes only O(log n) time instead of O(n) linear search.

Common Approaches

Approach	Time	Space	Notes
✓ Priority Queues (Optimal)	O(n log n)	O(n)	Use two heaps to efficiently access best buy and sell orders
Brute Force (Linear Search)	O(n²)	O(n)	For each order, scan through all existing orders to find matches

Priority Queues (Optimal) — Algorithm Steps

Create max-heap for buy orders (prioritize highest prices)
Create min-heap for sell orders (prioritize lowest prices)
For each buy order: match with cheapest sell orders while profitable
For each sell order: match with highest buy orders while profitable
Add unmatched portions to respective heaps
Sum all remaining orders in both heaps

Visualization

Tap to expand

Step-by-Step Walkthrough

Heap Structure

Max-heap for buy orders, min-heap for sell orders

Instant Access

O(1) access to best matching orders

Efficient Matching

O(log n) heap operations for matching

Update Heaps

Add unmatched orders back to heaps

Code -

solution.c — C

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

#define MOD 1000000007
#define MAXN 100005

typedef struct {
    int price;
    int amount;
} Order;

typedef struct {
    Order data[MAXN];
    int size;
} Heap;

void swap(Order* a, Order* b) {
    Order temp = *a;
    *a = *b;
    *b = temp;
}

void maxHeapify(Heap* heap, int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    
    if (left < heap->size && heap->data[left].price > heap->data[largest].price) {
        largest = left;
    }
    if (right < heap->size && heap->data[right].price > heap->data[largest].price) {
        largest = right;
    }
    if (largest != i) {
        swap(&heap->data[i], &heap->data[largest]);
        maxHeapify(heap, largest);
    }
}

void minHeapify(Heap* heap, int i) {
    int smallest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    
    if (left < heap->size && heap->data[left].price < heap->data[smallest].price) {
        smallest = left;
    }
    if (right < heap->size && heap->data[right].price < heap->data[smallest].price) {
        smallest = right;
    }
    if (smallest != i) {
        swap(&heap->data[i], &heap->data[smallest]);
        minHeapify(heap, smallest);
    }
}

void maxHeapPush(Heap* heap, Order order) {
    heap->data[heap->size] = order;
    int i = heap->size++;
    
    while (i > 0 && heap->data[(i-1)/2].price < heap->data[i].price) {
        swap(&heap->data[i], &heap->data[(i-1)/2]);
        i = (i-1)/2;
    }
}

void minHeapPush(Heap* heap, Order order) {
    heap->data[heap->size] = order;
    int i = heap->size++;
    
    while (i > 0 && heap->data[(i-1)/2].price > heap->data[i].price) {
        swap(&heap->data[i], &heap->data[(i-1)/2]);
        i = (i-1)/2;
    }
}

Order maxHeapPop(Heap* heap) {
    Order result = heap->data[0];
    heap->data[0] = heap->data[--heap->size];
    maxHeapify(heap, 0);
    return result;
}

Order minHeapPop(Heap* heap) {
    Order result = heap->data[0];
    heap->data[0] = heap->data[--heap->size];
    minHeapify(heap, 0);
    return result;
}

int getNumberOfBacklogOrders(int** orders, int ordersSize, int* ordersColSize) {
    Heap buyHeap = {.size = 0};
    Heap sellHeap = {.size = 0};
    
    for (int i = 0; i < ordersSize; i++) {
        int price = orders[i][0];
        int amount = orders[i][1];
        int type = orders[i][2];
        
        if (type == 0) { // Buy order
            int remaining = amount;
            
            while (sellHeap.size > 0 && sellHeap.data[0].price <= price && remaining > 0) {
                Order sell = minHeapPop(&sellHeap);
                
                if (sell.amount <= remaining) {
                    remaining -= sell.amount;
                } else {
                    minHeapPush(&sellHeap, (Order){sell.price, sell.amount - remaining});
                    remaining = 0;
                }
            }
            
            if (remaining > 0) {
                maxHeapPush(&buyHeap, (Order){price, remaining});
            }
        } else { // Sell order
            int remaining = amount;
            
            while (buyHeap.size > 0 && buyHeap.data[0].price >= price && remaining > 0) {
                Order buy = maxHeapPop(&buyHeap);
                
                if (buy.amount <= remaining) {
                    remaining -= buy.amount;
                } else {
                    maxHeapPush(&buyHeap, (Order){buy.price, buy.amount - remaining});
                    remaining = 0;
                }
            }
            
            if (remaining > 0) {
                minHeapPush(&sellHeap, (Order){price, remaining});
            }
        }
    }
    
    long long total = 0;
    for (int i = 0; i < buyHeap.size; i++) {
        total = (total + buyHeap.data[i].amount) % MOD;
    }
    for (int i = 0; i < sellHeap.size; i++) {
        total = (total + sellHeap.data[i].amount) % MOD;
    }
    
    return (int)total;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each order involves O(log n) heap operations, and we process n orders

⚡ Linearithmic

Space Complexity

O(n)

Store up to n orders in the two priority queues

⚡ Linearithmic Space

Constraints

1 ≤ orders.length ≤ 10⁵
orders[i].length == 3
1 ≤ pricei, amounti ≤ 10⁹
orderTypei is either 0 or 1
Large amounts require modulo arithmetic

52.0K Views

High Frequency

~25 min Avg. Time

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

📈 Stock Market Order Matching System

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Priority Queues (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler