Maintain Fractional Stock Inventory Across Orders

Problem Statement

Brokerages that offer fractional share trading often act as principal to fulfill customer orders. When a customer buys fractional shares, the brokerage provides them out of its own inventory; when a customer sells, the brokerage absorbs those shares into its inventory.

To manage market risk, the brokerage enforces a strict inventory rule: after every order, the firm's inventory for each stock must be strictly within the range [0, 1.0) shares (i.e., at least 0 shares, but strictly less than 1 whole share). Whenever inventory falls below 0 or reaches 1.0 or more, the brokerage immediately executes an external market order for whole shares to rebalance.

To prevent floating-point precision issues, all share quantities are tracked in micro-shares, where: 1 whole share = 1,000,000 micro-shares (SCALE = 10^6).

Given a list of customer orders, simulate the inventory changes sequentially and return the final state for every symbol.

Order Rules

For each order:

1. Convert the dollar amount to customer micro-shares using integer division: customer_shares = (dollar_amount * 1_000_000) // price
2. Update firm inventory based on customer action:
   • Customer "BUY": customer takes shares from the firm (inventory -= customer_shares).
   • Customer "SELL": customer delivers shares to the firm (inventory += customer_shares).
3. Rebalance firm inventory to satisfy 0 = 1_000_000: firm executes an external market SELL for inventory // 1_000_000 whole shares, removing them from inventory.

Each symbol starts with 0 inventory and 0 external market trades.

Function Signature

def simulate_fractional_trading(orders: list[dict]) -> list[dict]:
    pass

Each input order is a dictionary:

• "symbol" (str): Stock ticker symbol.
• "side" (str): "BUY" or "SELL".
• "dollar_amount" (int): Integer dollar amount.
• "price" (int): Price per share in dollars.

Return a list of dictionaries, sorted alphabetically by symbol, containing:

• "symbol" (str)
• "inventory" (int): Final inventory in micro-shares (0 <= inventory < 1_000_000).
• "market_buys" (int): Cumulative whole shares bought on the external market.
• "market_sells" (int): Cumulative whole shares sold on the external market.

Only include symbols that appeared in at least one order.

Examples

Example 1

orders = [
    {"symbol": "AAPL", "side": "BUY", "dollar_amount": 150, "price": 100},
    {"symbol": "AAPL", "side": "SELL", "dollar_amount": 70, "price": 100}
]

simulate_fractional_trading(orders)
# Output:
# [
#     {"symbol": "AAPL", "inventory": 200000, "market_buys": 2, "market_sells": 1}
# ]

Explanation:

1. Order 1: AAPL price = 100, amount = 150. Shares = (150 * 10^6) // 100 = 1_500_000. Customer buys, so inventory drops from 0 to -1_500_000. Firm buys ceil(1_500_000 / 10^6) = 2 whole shares from market. Inventory becomes 500_000 micro-shares. market_buys = 2.
2. Order 2: AAPL price = 100, amount = 70. Shares = 700_000. Customer sells, so inventory becomes 500_000 + 700_000 = 1_200_000. Firm sells 1_200_000 // 10^6 = 1 whole share to market. Inventory becomes 200_000. market_sells = 1.

Constraints

• 1 <= len(orders) <= 10^5
• 1 <= dollar_amount <= 10^8
• 1 <= price <= 10^8
• side is always "BUY" or "SELL"
• symbol consists of 1 to 5 uppercase ASCII letters.