In this approach, we utilize a dictionary (or map) to store the net capital gain/loss for each stock. We iterate through the provided data, performing operations as follows:

When encountering a 'Buy', simply append the price to a list for that stock.
When encountering a 'Sell', pair it with the earliest 'Buy' found in the list and calculate the gain or loss by subtracting the buy price from the sell price.
Update the total capital gain/loss for that stock in the dictionary.

This approach ensures that we maintain accurate running totals per stock by matching sells with the earliest buys (FIFO - First In, First Out) pattern.

Time Complexity is O(n), where n is the number of rows in the stock table, as we iterate through the list once and perform constant-time operations per row. Space Complexity is O(m), where m is the number of unique stocks in the list, since we maintain a list of prices for each stock.

Python Java

1def calculate_capital_gain_loss(stocks):
2    gains = {}
3
4    for stock in stocks:
5        name = stock['stock_name']
6        operation = stock['operation']
7        price = stock['price']
8
9        if operation == 'Buy':
10            if name not in gains:
11                gains[name] = {'prices': [], 'net': 0}
12            gains[name]['prices'].append(price)
13        elif operation == 'Sell':
14            buy_price = gains[name]['prices'].pop(0)
15            gain_loss = price - buy_price
16            gains[name]['net'] += gain_loss
17
18    result = [{'stock_name': k, 'capital_gain_loss': v['net']} for k, v in gains.items()]
19    return result

Explanation

In the Python solution, we create a dictionary `gains` keyed by `stock_name`. Each key holds a list of prices under the `'prices'` key and a running total `'net'` gain/loss. We iterate over each row in the `stocks` list: for each 'Buy' operation, we append the price to the price list; for each 'Sell' operation, we calculate the gain/loss using the first price in the list (FIFO), remove it, and update the net gain/loss.

Approach 2: Sorting and Calculating Gains/Losses

In this approach, we first sort the operations based on the operation day. Then, we iterate through the sorted list and calculate the cumulative gain/loss for each stock. Here's a step-by-step breakdown:

Sort the operations by `operation_day` to ensure we process the transactions in order.
As we iterate through the sorted list, maintain a running tally of buy and sell transactions per stock.
Use a dictionary to accumulate the total gain/loss for each stock as we encounter sell operations.

This approach benefits from leveraging the sorted order of operations to systematically apply transactions in a straightforward manner.

Time Complexity is O(n log n) due to the sorting of the stocks by their operation day, followed by O(n) processing time. Space Complexity is O(m) where m refers to the distinct stocks, as we maintain data structures for each stock's price history.

C++JavaScript

1function calculateCapitalGainLoss(stocks)

DSA Corner

Home

DSA Corner

DSA Corner

DSA Corner

DSA Corner

DSA Corner

DSA Corner

1393. Capital Gain/Loss

Approach 1: Using a Dictionary to Track Buys and Sells

Explanation

Approach 2: Sorting and Calculating Gains/Losses

Similar Problems

Related Topics

Problem Stats

Practice on LeetCode

Explanation