Stock Trading System

Problems to Solve

You will work with a comprehensive stock price dataset. Download the CSV files containing historical price data for analysis:

Dataset Schema

Stocks/
├── aapl.us.txt     # Apple Inc.
├── googl.us.txt    # Alphabet Inc.
├── msft.us.txt     # Microsoft
├── amzn.us.txt     # Amazon
├── tsla.us.txt     # Tesla
└── ... (7,000+ more)

// Example: Reading close prices from CSV
int[] prices = {7, 1, 5, 3, 6, 4}; // From Close column

// This becomes input for:
// - Best Time to Buy and Sell Stock I, II, III, IV
// - Stock with Cooldown
// - Stock with Transaction Fee

Sample Data Preview

Here is what the data looks like from aapl.us.txt (Apple stock):

Your project must include all of the following components. Structure your code with clear organization, documentation, and comprehensive testing.

Implement the following algorithms with optimal time and space complexity. Each algorithm should be thoroughly tested and documented.

// Example:
// prices = [7, 1, 5, 3, 6, 4]
// Output: 5 (buy at 1, sell at 6)

public int maxProfit(int[] prices) {
    int minPrice = Integer.MAX_VALUE;
    int maxProfit = 0;
    for (int price : prices) {
        minPrice = Math.min(minPrice, price);
        maxProfit = Math.max(maxProfit, price - minPrice);
    }
    return maxProfit;
}

// Example:
// prices = [7, 1, 5, 3, 6, 4]
// Output: 7 (buy@1 sell@5, buy@3 sell@6)

public int maxProfit(int[] prices) {
    int profit = 0;
    for (int i = 1; i < prices.length; i++) {
        if (prices[i] > prices[i - 1]) {
            profit += prices[i] - prices[i - 1];
        }
    }
    return profit;
}

// Dynamic Programming approach
// dp[i][j] = max profit using i transactions 
//            up to day j

public int maxProfit(int k, int[] prices) {
    int n = prices.length;
    if (k >= n / 2) {
        return unlimitedTransactions(prices);
    }
    int[][] dp = new int[k + 1][n];
    // ... implementation
}

// State machine approach:
// hold = max profit while holding stock
// sold = max profit just sold
// rest = max profit in cooldown

public int maxProfit(int[] prices) {
    int hold = Integer.MIN_VALUE;
    int sold = 0, rest = 0;
    for (int price : prices) {
        int prevSold = sold;
        sold = hold + price;
        hold = Math.max(hold, rest - price);
        rest = Math.max(rest, prevSold);
    }
    return Math.max(sold, rest);
}

Build custom data structures optimized for stock trading operations. Each structure should have documented methods, time complexity, and test cases.

class StockSpan {
    private Stack<int[]> stack; // [price, span]
    
    public int next(int price) {
        int span = 1;
        while (!stack.isEmpty() && 
               stack.peek()[0] <= price) {
            span += stack.pop()[1];
        }
        stack.push(new int[]{price, span});
        return span;
    }
}

class StockPriceTracker {
    private Map<Integer, Integer> prices;
    private TreeMap<Integer, Integer> priceCounts;
    private int latestTime;
    
    public void update(int time, int price) {...}
    public int current() {...}
    public int maximum() {...}
    public int minimum() {...}
}

class Portfolio {
    private Map<String, Holding> holdings;
    
    public void buy(String symbol, int qty, double price);
    public void sell(String symbol, int qty, double price);
    public double getValue(Map<String, Double> prices);
    public double getTotalProfit();
    public List<Holding> getHoldings();
}

class TopKStocks {
    private PriorityQueue<Stock> minHeap;
    private int k;
    
    public void update(String symbol, double gain);
    public List<Stock> getTopK();
    public boolean isTopK(String symbol);
}

Create a public GitHub repository with the exact name shown below:

Required Project Structure

stock-trading-system/
├── src/
│   ├── main/java/com/trading/
│   │   ├── algorithms/
│   │   │   ├── SingleTransaction.java
│   │   │   ├── UnlimitedTransactions.java
│   │   │   ├── KTransactions.java
│   │   │   ├── WithCooldown.java
│   │   │   └── WithTransactionFee.java
│   │   ├── datastructures/
│   │   │   ├── StockSpan.java
│   │   │   ├── StockPriceTracker.java
│   │   │   ├── Portfolio.java
│   │   │   └── TopKStocks.java
│   │   ├── models/
│   │   │   ├── Stock.java
│   │   │   └── Holding.java
│   │   └── Main.java
│   └── test/java/com/trading/
│       ├── algorithms/
│       └── datastructures/
├── data/
│   ├── stock_prices.csv
│   ├── stock_metadata.csv
│   └── sample_portfolios.csv
├── docs/
│   ├── algorithm_analysis.md
│   └── complexity_comparison.md
└── README.md

Your project will be graded on the following criteria. Total: 500 points.

Grading Levels