Constraints

• 0 <= len(transactions) <= 10^5
• timestamp fits in 64-bit signed integer
• amount fits in 64-bit signed integer
• Each transaction string is well-formed

Examples

Solution

def solution(transactions):
    balances = {}
    for record in transactions:
        account_id, _timestamp, currency, amount = record.split(',')
        key = (account_id, currency)
        balances[key] = balances.get(key, 0) + int(amount)

    rows = []
    for (account_id, currency), balance in balances.items():
        if balance != 0:
            rows.append((account_id, currency, balance))
    rows.sort()

    return [f'{account_id},{currency},{balance}' for account_id, currency, balance in rows]

Time complexity: O(n + k log k), where n is the number of transactions and k is the number of distinct (account_id, currency) pairs. Space complexity: O(k).

Hints

1. Use a hash map keyed by (account_id, currency).
2. Aggregate first, then filter out zero balances and sort once at the end.

Constraints

• 0 <= len(transactions) <= 10^5
• timestamp fits in 64-bit signed integer
• amount fits in 64-bit signed integer
• Each transaction string is well-formed

Examples

Solution

def solution(transactions):
    ordered = []
    for index, record in enumerate(transactions):
        account_id, timestamp, currency, amount = record.split(',')
        ordered.append((int(timestamp), index, account_id, currency, int(amount)))
    ordered.sort()

    balances = {}
    for _timestamp, _index, account_id, currency, amount in ordered:
        key = (account_id, currency)
        current = balances.get(key, 0)

        if amount < 0 and current + amount < 0:
            continue

        new_balance = current + amount
        if new_balance == 0:
            balances.pop(key, None)
        else:
            balances[key] = new_balance

    rows = [(account_id, currency, balance) for (account_id, currency), balance in balances.items()]
    rows.sort()
    return [f'{account_id},{currency},{balance}' for account_id, currency, balance in rows]

Time complexity: O(n log n + k log k), where n is the number of transactions and k is the number of distinct (account_id, currency) pairs. Space complexity: O(n + k).

Hints

1. Sort by timestamp, but keep the original index so ties follow input order.
2. Before applying a debit, check whether current_balance + amount would be negative.

Constraints

• 0 <= len(transactions) <= 10^5
• timestamp fits in 64-bit signed integer
• amount fits in 64-bit signed integer
• platform_account_id is a string identifier
• Each transaction string is well-formed

Examples

Solution

def solution(transactions, platform_account_id):
    ordered = []
    for index, record in enumerate(transactions):
        account_id, timestamp, currency, amount = record.split(',')
        ordered.append((int(timestamp), index, account_id, currency, int(amount)))
    ordered.sort()

    balances = {}

    def set_balance(key, value):
        if value == 0:
            balances.pop(key, None)
        else:
            balances[key] = value

    for _timestamp, _index, account_id, currency, amount in ordered:
        key = (account_id, currency)
        current = balances.get(key, 0)

        if amount >= 0:
            set_balance(key, current + amount)
            continue

        debit = -amount

        if current >= debit:
            set_balance(key, current - debit)
            continue

        if account_id == platform_account_id:
            continue

        shortfall = debit - current
        platform_key = (platform_account_id, currency)
        platform_balance = balances.get(platform_key, 0)

        if platform_balance < shortfall:
            continue

        set_balance(key, 0)
        set_balance(platform_key, platform_balance - shortfall)

    rows = [(account_id, currency, balance) for (account_id, currency), balance in balances.items()]
    rows.sort()
    return [f'{account_id},{currency},{balance}' for account_id, currency, balance in rows]

Time complexity: O(n log n + k log k), where n is the number of transactions and k is the number of distinct (account_id, currency) pairs. Space complexity: O(n + k).

Hints

1. For an insufficient debit, compute shortfall = debit_amount - account_balance.
2. Only change balances after confirming the platform has enough in the same currency.