Number of Orders in the Backlog - Practice Coding Problems

Number of Orders in the Backlog - Problem

You are given a 2D integer array orders, where each orders[i] = [pricei, amounti, orderTypei] denotes that amounti orders have been placed of type orderTypei at the price pricei. The orderTypei is:

0 if it is a batch of buy orders, or
1 if it is a batch of sell orders.

There is a backlog that consists of orders that have not been executed. The backlog is initially empty. When an order is placed, the following happens:

If the order is a buy order, you look at the sell order with the smallest price in the backlog. If that sell order's price is smaller than or equal to the current buy order's price, they will match and be executed, and that sell order will be removed from the backlog. Else, the buy order is added to the backlog.
Vice versa, if the order is a sell order, you look at the buy order with the largest price in the backlog. If that buy order's price is larger than or equal to the current sell order's price, they will match and be executed, and that buy order will be removed from the backlog. Else, the sell order is added to the backlog.

Return the total amount of orders in the backlog after placing all the orders from the input. Since this number can be large, return it modulo 10^9 + 7.

Input & Output

Example 1 — Basic Matching

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

› Output: 6

💡 Note: Buy 10 (5 units) matches with sell 15 (2 units), leaving buy 10 (3 units). Sell 25 (1 unit) matches with buy 30 (4 units), leaving buy 30 (3 units). Total backlog: 3 + 3 = 6

Example 2 — No Matches

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

› Output: 999999984

💡 Note: Sell 7 can't match with any buy order, buy orders can't match with remaining sell. Only some units of large sell order get matched.

Example 3 — Complete Match

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

› Output: 1

💡 Note: Buy 10 (2 units) matches with sell 8 (3 units) since 8 ≤ 10. 2 units matched, leaving sell 8 (1 unit) in backlog.

Constraints

1 ≤ orders.length ≤ 10⁵
orders[i].length == 3
1 ≤ price_i, amount_i ≤ 10⁹
orderType_i is either 0 or 1

Visualization

Tap to expand

Understanding the Visualization

Input Orders

Process buy/sell orders with price, amount, and type

Match Orders

Buy orders match with sell orders at compatible prices

Count Backlog

Sum all unmatched orders remaining in the system

Key Takeaway

🎯 Key Insight: Use max-heap for buy orders and min-heap for sell orders to instantly access the best matching prices

Asked in

a Amazon 35 M Microsoft 28 G Google 22 A Apple 18

The key insight is to use priority queues (heaps) for efficient order matching. Max-heap for buy orders gives instant access to highest bid prices, while min-heap for sell orders gives instant access to lowest ask prices. Best approach is Priority Queue with Time: O(n log n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force with Lists	O(n²)	O(n)	Use lists to store orders and linearly search for matches
Priority Queue (Optimal)	O(n log n)	O(n)	Use max-heap for buy orders and min-heap for sell orders for efficient matching

Brute Force with Lists — Algorithm Steps

Store buy and sell orders in separate lists
For each new order, scan through opposite type orders
Match and remove compatible orders
Add unmatched orders to backlog

Visualization

Tap to expand

Step-by-Step Walkthrough

New Order

Process incoming buy/sell order

Linear Search

Scan through opposite type orders for matches

Match & Update

Execute trades and update remaining amounts

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_ORDERS 100000

struct Order {
    int price;
    int amount;
};

int solution(int orders[][3], int n) {
    struct Order buyOrders[MAX_ORDERS], sellOrders[MAX_ORDERS];
    int buyCount = 0, sellCount = 0;
    
    for (int idx = 0; idx < n; idx++) {
        int price = orders[idx][0], amount = orders[idx][1], type = orders[idx][2];
        
        if (type == 0) {
            int remaining = amount;
            int i = 0;
            while (i < sellCount && remaining > 0) {
                if (sellOrders[i].price <= price) {
                    int matched = (remaining < sellOrders[i].amount) ? remaining : sellOrders[i].amount;
                    remaining -= matched;
                    sellOrders[i].amount -= matched;
                    if (sellOrders[i].amount == 0) {
                        for (int j = i; j < sellCount - 1; j++) {
                            sellOrders[j] = sellOrders[j + 1];
                        }
                        sellCount--;
                    } else {
                        i++;
                    }
                } else {
                    i++;
                }
            }
            
            if (remaining > 0) {
                buyOrders[buyCount++] = (struct Order){price, remaining};
            }
        } else {
            int remaining = amount;
            int i = 0;
            while (i < buyCount && remaining > 0) {
                if (buyOrders[i].price >= price) {
                    int matched = (remaining < buyOrders[i].amount) ? remaining : buyOrders[i].amount;
                    remaining -= matched;
                    buyOrders[i].amount -= matched;
                    if (buyOrders[i].amount == 0) {
                        for (int j = i; j < buyCount - 1; j++) {
                            buyOrders[j] = buyOrders[j + 1];
                        }
                        buyCount--;
                    } else {
                        i++;
                    }
                } else {
                    i++;
                }
            }
            
            if (remaining > 0) {
                sellOrders[sellCount++] = (struct Order){price, remaining};
            }
        }
    }
    
    long long total = 0;
    for (int i = 0; i < buyCount; i++) total += buyOrders[i].amount;
    for (int i = 0; i < sellCount; i++) total += sellOrders[i].amount;
    return (int)(total % MOD);
}

int main() {
    char line[1000000];
    fgets(line, sizeof(line), stdin);
    
    int orders[MAX_ORDERS][3];
    int n = 0;
    
    char *ptr = line + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            orders[n][0] = strtol(ptr, &ptr, 10);
            ptr++; // Skip comma
            orders[n][1] = strtol(ptr, &ptr, 10);
            ptr++; // Skip comma
            orders[n][2] = strtol(ptr, &ptr, 10);
            n++;
        }
        ptr++;
    }
    
    printf("%d\n", solution(orders, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each order, we might scan through all existing orders to find matches

⚠ Quadratic Growth

Space Complexity

O(n)

Store all orders in lists

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

892 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 with Lists — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler