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

1import java.util.*;
2
3public List<Map<String, Object>> calculateCapitalGainLoss(List<Map<String, Object>> stocks) {
4    Map<String, List<Integer>> buyPrices = new HashMap<>();
5    Map<String, Integer> netGains = new HashMap<>();
6
7    for (Map<String, Object> stock : stocks) {
8        String name = (String)stock.get("stock_name");
9        String operation = (String)stock.get("operation");
10        int price = (int)stock.get("price");
11
12        if (operation.equals("Buy")) {
13            buyPrices.putIfAbsent(name, new LinkedList<>());
14            buyPrices.get(name).add(price);
15        } else if (operation.equals("Sell")) {
16            int buyPrice = buyPrices.get(name).remove(0);
17            int gainLoss = price - buyPrice;
18            netGains.put(name, netGains.getOrDefault(name, 0) + gainLoss);
19        }
20    }
21
22    List<Map<String, Object>> result = new ArrayList<>();
23    for (String name : netGains.keySet()) {
24        Map<String, Object> entry = new HashMap<>();
25        entry.put("stock_name", name);
26        entry.put("capital_gain_loss", netGains.get(name));
27        result.add(entry);
28    }
29    return result;
30}

Explanation

The Java solution creates two maps: `buyPrices` to manage a queue (using `LinkedList`) of buy prices for each stock and `netGains` to track the cumulative gain/loss. As we process each stock entry, buys are added to the respective stock queue, and for sells, the gain/loss is computed by dequeuing the earliest buy price and summing to the net gain. Finally, the results are collated into a list of maps for output.

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