Is Design Order Management System easy or hard?

Design Order Management System is typically considered a medium difficulty problem. The core implementation with a hash map is straightforward, but interviewers often expect clean class design and efficient handling of updates and queries.

Design Order Management System Python/Java solution

In Python, a dictionary can map orderId to an Order object, giving O(1) average lookup. In Java, HashMap is commonly used. Both implementations follow the same pattern: store orders by ID and update or retrieve them with direct hash lookups.

How to solve Design Order Management System in O(n)?

A simple implementation stores all orders in a list and iterates through it to locate the required order. Each search or update scans the entire collection, giving O(n) time per operation. This approach is easy to implement but does not scale well compared to the O(1) hash table solution.

What is the best approach for Design Order Management System?

The most effective approach uses a hash table keyed by order ID. This allows constant-time O(1) average operations for creating, retrieving, updating, and deleting orders. The design mirrors how real backend services store transactional objects where fast lookups are critical.

Is Design Order Management System asked at Google/Amazon/Meta?

Design-style data structure problems using hash tables appear frequently in interviews at companies like Amazon, Google, and Meta. Variations of order tracking, task management, or object registries test the candidate's ability to combine hash maps with clean system design.

What data structure is used in Design Order Management System?

The core data structure is a hash table (hash map) that maps order IDs to order objects. Some implementations also maintain additional maps such as user-to-orders or status-to-orders to support efficient queries.

What is the time complexity of Design Order Management System?

Using a hash table, most operations such as create, get, update, and delete run in O(1) average time. Space complexity is O(n) because each order must be stored in memory. A naive list-based design would require O(n) lookup time.

Description Hints 3 Solution Video 4:00

3822. Design Order Management System

Medium79.0% acceptance1 companyPremium elsewhere, free here

You are asked to design a simple order management system for a trading platform.

Each order is associated with an orderId, an orderType ("buy" or "sell"), and a price.

An order is considered active unless it is canceled.

Implement the OrderManagementSystem class:

OrderManagementSystem(): Initializes the order management system.
void addOrder(int orderId, string orderType, int price): Adds a new active order with the given attributes. It is guaranteed that orderId is unique.
void modifyOrder(int orderId, int newPrice): Modifies the price of an existing order. It is guaranteed that the order exists and is active.
void cancelOrder(int orderId): Cancels an existing order. It is guaranteed that the order exists and is active.
vector<int> getOrdersAtPrice(string orderType, int price): Returns the orderIds of all active orders that match the given orderType and price. If no such orders exist, return an empty list.

Note: The order of returned orderIds does not matter.

Example 1:

Input:
["OrderManagementSystem", "addOrder", "addOrder", "addOrder", "getOrdersAtPrice", "modifyOrder", "modifyOrder", "getOrdersAtPrice", "cancelOrder", "cancelOrder", "getOrdersAtPrice"]
[[], [1, "buy", 1], [2, "buy", 1], [3, "sell", 2], ["buy", 1], [1, 3], [2, 1], ["buy", 1], [3], [2], ["buy", 1]]

Output:
[null, null, null, null, [2, 1], null, null, [2], null, null, []]

Explanation

OrderManagementSystem orderManagementSystem = new OrderManagementSystem();
orderManagementSystem.addOrder(1, "buy", 1); // A buy order with ID 1 is added at price 1.
orderManagementSystem.addOrder(2, "buy", 1); // A buy order with ID 2 is added at price 1.
orderManagementSystem.addOrder(3, "sell", 2); // A sell order with ID 3 is added at price 2.
orderManagementSystem.getOrdersAtPrice("buy", 1); // Both buy orders (IDs 1 and 2) are active at price 1, so the result is [2, 1].
orderManagementSystem.modifyOrder(1, 3); // Order 1 is updated: its price becomes 3.
orderManagementSystem.modifyOrder(2, 1); // Order 2 is updated, but its price remains 1.
orderManagementSystem.getOrdersAtPrice("buy", 1); // Only order 2 is still an active buy order at price 1, so the result is [2].
orderManagementSystem.cancelOrder(3); // The sell order with ID 3 is canceled and removed from active orders.
orderManagementSystem.cancelOrder(2); // The buy order with ID 2 is canceled and removed from active orders.
orderManagementSystem.getOrdersAtPrice("buy", 1); // There are no active buy orders left at price 1, so the result is [].

Constraints:

1 <= orderId <= 2000
orderId is unique across all orders.
orderType is either "buy" or "sell".
1 <= price <= 10⁹
The total number of calls to addOrder, modifyOrder, cancelOrder, and getOrdersAtPrice does not exceed 2000.
For modifyOrder and cancelOrder, the specified orderId is guaranteed to exist and be active.

Asked at 1 company

Optiver

Topics

Design Hash Table

Hints open one at a time

Hint 1

Keep track of orders by their orderId so you can quickly modify or cancel them.

Hint 2

Group active orders by (orderType, price) to efficiently answer queries.

Hint 3

When an order is modified or canceled, make sure all related data structures stay in sync.

4:00

Still stuck?Read the written solution, or watch a walkthrough.

Open solution

LanguageLoading editor…

1class Solution:
  def solve(self):
      pass


Starter codePython 3Spaces: 4

Examples

Case 1

Input

["OrderManagementSystem","addOrder","addOrder","addOrder","getOrdersAtPrice","modifyOrder","modifyOrder","getOrdersAtPrice","cancelOrder","cancelOrder","getOrdersAtPrice"]
[[],[1,"buy",1],[2,"buy",1],[3,"sell",2],["buy",1],[1,3],[2,1],["buy",1],[3],[2],["buy",1]]

Your code is saved on this device.Solution