extras/trading/trades_claude.py

# tickers is a list of stock tickers
import tickers

# prices is a dict; the key is a ticker and the value is a list of historic prices, today first
import prices

# Trade represents a decision to buy or sell a quantity of a ticker
import Trade

import random
import numpy as np

def trade2():
    # Buy if the current price is lower than the average of the last 5 days
    trades = []
    for ticker in tickers:
        if prices[ticker][0] < np.mean(prices[ticker][1:6]):
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade3():
    # Sell if the current price is higher than the average of the last 10 days
    trades = []
    for ticker in tickers:
        if prices[ticker][0] > np.mean(prices[ticker][1:11]):
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade4():
    # Buy if the current price is the lowest in the last 3 days
    trades = []
    for ticker in tickers:
        if prices[ticker][0] == min(prices[ticker][:3]):
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade5():
    # Sell if the current price is the highest in the last 3 days
    trades = []
    for ticker in tickers:
        if prices[ticker][0] == max(prices[ticker][:3]):
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade6():
    # Buy if the current price is higher than the previous day's price
    trades = []
    for ticker in tickers:
        if prices[ticker][0] > prices[ticker][1]:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade7():
    # Sell if the current price is lower than the previous day's price
    trades = []
    for ticker in tickers:
        if prices[ticker][0] < prices[ticker][1]:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade8():
    # Buy if the current price is higher than the average of the last 20 days
    trades = []
    for ticker in tickers:
        if prices[ticker][0] > np.mean(prices[ticker][1:21]):
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade9():
    # Sell if the current price is lower than the average of the last 20 days
    trades = []
    for ticker in tickers:
        if prices[ticker][0] < np.mean(prices[ticker][1:21]):
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade10():
    # Buy if the current price is higher than the highest price in the last 5 days
    trades = []
    for ticker in tickers:
        if prices[ticker][0] > max(prices[ticker][1:6]):
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade11():
    # Sell if the current price is lower than the lowest price in the last 5 days
    trades = []
    for ticker in tickers:
        if prices[ticker][0] < min(prices[ticker][1:6]):
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade12():
    # Long/Short: Buy the best-performing stock and sell the worst-performing stock in the last 10 days
    best_ticker = max(tickers, key=lambda x: (prices[x][0] - prices[x][9]) / prices[x][9])
    worst_ticker = min(tickers, key=lambda x: (prices[x][0] - prices[x][9]) / prices[x][9])
    return [Trade(best_ticker, 100), Trade(worst_ticker, -100)]

def trade13():
    # Buy if the 5-day moving average crosses above the 20-day moving average
    trades = []
    for ticker in tickers:
        if np.mean(prices[ticker][:5]) > np.mean(prices[ticker][:20]) and np.mean(prices[ticker][1:6]) <= np.mean(prices[ticker][1:21]):
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade14():
    # Sell if the 5-day moving average crosses below the 20-day moving average
    trades = []
    for ticker in tickers:
        if np.mean(prices[ticker][:5]) < np.mean(prices[ticker][:20]) and np.mean(prices[ticker][1:6]) >= np.mean(prices[ticker][1:21]):
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade15():
    # Buy if the current volume is higher than the average volume of the last 10 days
    trades = []
    for ticker in tickers:
        if volumes[ticker][0] > np.mean(volumes[ticker][1:11]):
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade16():
    # Sell if the current volume is lower than the average volume of the last 10 days
    trades = []
    for ticker in tickers:
        if volumes[ticker][0] < np.mean(volumes[ticker][1:11]):
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade17():
    # Long/Short: Buy the stock with the highest relative strength index (RSI) and sell the stock with the lowest RSI
    rsi = {}
    for ticker in tickers:
        gains = [max(prices[ticker][i] - prices[ticker][i+1], 0) for i in range(13)]
        losses = [max(prices[ticker][i+1] - prices[ticker][i], 0) for i in range(13)]
        avg_gain = sum(gains) / 14
        avg_loss = sum(losses) / 14
        rs = avg_gain / avg_loss if avg_loss > 0 else 100
        rsi[ticker] = 100 - (100 / (1 + rs))
    best_ticker = max(tickers, key=lambda x: rsi[x])
    worst_ticker = min(tickers, key=lambda x: rsi[x])
    return [Trade(best_ticker, 100), Trade(worst_ticker, -100)]

def trade18():
    # Buy if the current price is higher than the 50-day moving average and the 50-day moving average is higher than the 200-day moving average
    trades = []
    for ticker in tickers:
        if prices[ticker][0] > np.mean(prices[ticker][:50]) > np.mean(prices[ticker][:200]):
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade19():
    # Sell if the current price is lower than the 50-day moving average and the 50-day moving average is lower than the 200-day moving average
    trades = []
    for ticker in tickers:
        if prices[ticker][0] < np.mean(prices[ticker][:50]) < np.mean(prices[ticker][:200]):
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade20():
    # Long/Short: Buy the stock with the highest momentum and sell the stock with the lowest momentum
    momentums = {}
    for ticker in tickers:
        momentums[ticker] = prices[ticker][0] - prices[ticker][19]
    best_ticker = max(tickers, key=lambda x: momentums[x])
    worst_ticker = min(tickers, key=lambda x: momentums[x])
    return [Trade(best_ticker, 100), Trade(worst_ticker, -100)]

def trade21():
    # Buy if the current price is higher than the upper Bollinger Band
    trades = []
    for ticker in tickers:
        sma = np.mean(prices[ticker][:20])
        std = np.std(prices[ticker][:20])
        upper_band = sma + 2 * std
        if prices[ticker][0] > upper_band:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade22():
    # Sell if the current price is lower than the lower Bollinger Band
    trades = []
    for ticker in tickers:
        sma = np.mean(prices[ticker][:20])
        std = np.std(prices[ticker][:20])
        lower_band = sma - 2 * std
        if prices[ticker][0] < lower_band:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade23():
    # Buy if the current volatility is higher than the average volatility of the last 10 days
    trades = []
    for ticker in tickers:
        volatility = np.std(prices[ticker][:10])
        avg_volatility = np.mean([np.std(prices[ticker][i:i+10]) for i in range(10)])
        if volatility > avg_volatility:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade24():
    # Sell if the current volatility is lower than the average volatility of the last 10 days
    trades = []
    for ticker in tickers:
        volatility = np.std(prices[ticker][:10])
        avg_volatility = np.mean([np.std(prices[ticker][i:i+10]) for i in range(10)])
        if volatility < avg_volatility:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade25():
    # Long/Short: Buy the stock with the lowest volatility and sell the stock with the highest volatility
    volatilities = {}
    for ticker in tickers:
        volatilities[ticker] = np.std(prices[ticker][:10])
    best_ticker = min(tickers, key=lambda x: volatilities[x])
    worst_ticker = max(tickers, key=lambda x: volatilities[x])
    return [Trade(best_ticker, 100), Trade(worst_ticker, -100)]

def trade26():
    # Buy if the current price is higher than the 20-day exponential moving average (EMA)
    trades = []
    for ticker in tickers:
        ema = prices[ticker][0]
        multiplier = 2 / (20 + 1)
        for i in range(1, 20):
            ema = (prices[ticker][i] - ema) * multiplier + ema
        if prices[ticker][0] > ema:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade27():
    # Sell if the current price is lower than the 20-day exponential moving average (EMA)
    trades = []
    for ticker in tickers:
        ema = prices[ticker][0]
        multiplier = 2 / (20 + 1)
        for i in range(1, 20):
            ema = (prices[ticker][i] - ema) * multiplier + ema
        if prices[ticker][0] < ema:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade28():
    # Buy if the current price is higher than the upper Keltner Channel
    trades = []
    for ticker in tickers:
        ema = prices[ticker][0]
        multiplier = 2 / (20 + 1)
        for i in range(1, 20):
            ema = (prices[ticker][i] - ema) * multiplier + ema
        atr = np.mean([np.max(prices[ticker][i:i+10]) - np.min(prices[ticker][i:i+10]) for i in range(10)])
        upper_channel = ema + 2 * atr
        if prices[ticker][0] > upper_channel:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade29():
    # Sell if the current price is lower than the lower Keltner Channel
    trades = []
    for ticker in tickers:
        ema = prices[ticker][0]
        multiplier = 2 / (20 + 1)
        for i in range(1, 20):
            ema = (prices[ticker][i] - ema) * multiplier + ema
        atr = np.mean([np.max(prices[ticker][i:i+10]) - np.min(prices[ticker][i:i+10]) for i in range(10)])
        lower_channel = ema - 2 * atr
        if prices[ticker][0] < lower_channel:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade30():
    # Long/Short: Buy the stock with the highest Sharpe ratio and sell the stock with the lowest Sharpe ratio
    sharpe_ratios = {}
    for ticker in tickers:
        returns = [prices[ticker][i] / prices[ticker][i+1] - 1 for i in range(19)]
        sharpe_ratios[ticker] = np.mean(returns) / np.std(returns)
    best_ticker = max(tickers, key=lambda x: sharpe_ratios[x])
    worst_ticker = min(tickers, key=lambda x: sharpe_ratios[x])
    return [Trade(best_ticker, 100), Trade(worst_ticker, -100)]

def trade31():
    # Buy if the current price is higher than the Ichimoku Cloud conversion line
    trades = []
    for ticker in tickers:
        conversion_line = (np.max(prices[ticker][:9]) + np.min(prices[ticker][:9])) / 2
        if prices[ticker][0] > conversion_line:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade32():
    # Buy if the current price is higher than the price 5 days ago
    trades = []
    for ticker in tickers:
        if prices[ticker][0] > prices[ticker][4]:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade33():
    # Sell if the current price is lower than the price 5 days ago
    trades = []
    for ticker in tickers:
        if prices[ticker][0] < prices[ticker][4]:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade34():
    # Buy if the current price is the highest in the last 15 days
    trades = []
    for ticker in tickers:
        if prices[ticker][0] == max(prices[ticker][:15]):
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade35():
    # Sell if the current price is the lowest in the last 15 days
    trades = []
    for ticker in tickers:
        if prices[ticker][0] == min(prices[ticker][:15]):
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade36():
    # Buy if the current price is higher than the 10-day simple moving average (SMA)
    trades = []
    for ticker in tickers:
        sma = np.mean(prices[ticker][:10])
        if prices[ticker][0] > sma:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade37():
    # Sell if the current price is lower than the 10-day simple moving average (SMA)
    trades = []
    for ticker in tickers:
        sma = np.mean(prices[ticker][:10])
        if prices[ticker][0] < sma:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade38():
    # Buy if the current price is higher than the highest price in the last 20 days
    trades = []
    for ticker in tickers:
        if prices[ticker][0] > max(prices[ticker][:20]):
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade39():
    # Sell if the current price is lower than the lowest price in the last 20 days
    trades = []
    for ticker in tickers:
        if prices[ticker][0] < min(prices[ticker][:20]):
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade40():
    # Buy if the current price is higher than the 50-day SMA
    trades = []
    for ticker in tickers:
        sma = np.mean(prices[ticker][:50])
        if prices[ticker][0] > sma:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade41():
    # Sell if the current price is lower than the 50-day SMA
    trades = []
    for ticker in tickers:
        sma = np.mean(prices[ticker][:50])
        if prices[ticker][0] < sma:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade42():
    # Buy if the current price is higher than the previous 2 days (a simple uptrend)
    trades = []
    for ticker in tickers:
        if prices[ticker][0] > prices[ticker][1] > prices[ticker][2]:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade43():
    # Sell if the current price is lower than the previous 2 days (a simple downtrend)
    trades = []
    for ticker in tickers:
        if prices[ticker][0] < prices[ticker][1] < prices[ticker][2]:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade44():
    # Buy if the current price is higher than the previous day's high (a breakout)
    trades = []
    for ticker in tickers:
        if prices[ticker][0] > max(prices[ticker][1:2]):
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade45():
    # Sell if the current price is lower than the previous day's low (a breakdown)
    trades = []
    for ticker in tickers:
        if prices[ticker][0] < min(prices[ticker][1:2]):
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade46():
    # Buy if the current price is above the previous day's high and the previous day was a down day (a potential reversal)
    trades = []
    for ticker in tickers:
        if prices[ticker][0] > max(prices[ticker][1:2]) and prices[ticker][1] < prices[ticker][2]:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade47():
    # Sell if the current price is below the previous day's low and the previous day was an up day (a potential reversal)
    trades = []
    for ticker in tickers:
        if prices[ticker][0] < min(prices[ticker][1:2]) and prices[ticker][1] > prices[ticker][2]:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade48():
    # Buy if the current price is above the 5-day SMA and the 5-day SMA is above the 10-day SMA (a bullish crossover)
    trades = []
    for ticker in tickers:
        sma5 = np.mean(prices[ticker][:5])
        sma10 = np.mean(prices[ticker][:10])
        if prices[ticker][0] > sma5 > sma10:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade49():
    # Sell if the current price is below the 5-day SMA and the 5-day SMA is below the 10-day SMA (a bearish crossover)
    trades = []
    for ticker in tickers:
        sma5 = np.mean(prices[ticker][:5])
        sma10 = np.mean(prices[ticker][:10])
        if prices[ticker][0] < sma5 < sma10:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade50():
    # Buy if the current price is above the 50-day SMA and the previous price was below the 50-day SMA (a bullish breakthrough)
    trades = []
    for ticker in tickers:
        sma50 = np.mean(prices[ticker][:50])
        if prices[ticker][0] > sma50 and prices[ticker][1] < sma50:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade51():
    # Sell if the current price is below the 50-day SMA and the previous price was above the 50-day SMA (a bearish breakthrough)
    trades = []
    for ticker in tickers:
        sma50 = np.mean(prices[ticker][:50])
        if prices[ticker][0] < sma50 and prices[ticker][1] > sma50:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade52():
    # Buy if the current price is more than 2 standard deviations below the 20-day mean (a potential oversold condition)
    trades = []
    for ticker in tickers:
        mean20 = np.mean(prices[ticker][:20])
        std20 = np.std(prices[ticker][:20])
        if prices[ticker][0] < mean20 - 2 * std20:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade53():
    # Sell if the current price is more than 2 standard deviations above the 20-day mean (a potential overbought condition)
    trades = []
    for ticker in tickers:
        mean20 = np.mean(prices[ticker][:20])
        std20 = np.std(prices[ticker][:20])
        if prices[ticker][0] > mean20 + 2 * std20:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade54():
    # Buy if the current price is below the 50-day mean and the 50-day mean is increasing (a potential uptrend)
    trades = []
    for ticker in tickers:
        mean50 = np.mean(prices[ticker][:50])
        prev_mean50 = np.mean(prices[ticker][1:51])
        if prices[ticker][0] < mean50 and mean50 > prev_mean50:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade55():
    # Sell if the current price is above the 50-day mean and the 50-day mean is decreasing (a potential downtrend)
    trades = []
    for ticker in tickers:
        mean50 = np.mean(prices[ticker][:50])
        prev_mean50 = np.mean(prices[ticker][1:51])
        if prices[ticker][0] > mean50 and mean50 < prev_mean50:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade56():
    # Buy if the 5-day mean is above the 50-day mean and the 5-day mean was previously below the 50-day mean (a potential trend change)
    trades = []
    for ticker in tickers:
        mean5 = np.mean(prices[ticker][:5])
        mean50 = np.mean(prices[ticker][:50])
        prev_mean5 = np.mean(prices[ticker][1:6])
        if mean5 > mean50 and prev_mean5 < mean50:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade57():
    # Sell if the 5-day mean is below the 50-day mean and the 5-day mean was previously above the 50-day mean (a potential trend change)
    trades = []
    for ticker in tickers:
        mean5 = np.mean(prices[ticker][:5])
        mean50 = np.mean(prices[ticker][:50])
        prev_mean5 = np.mean(prices[ticker][1:6])
        if mean5 < mean50 and prev_mean5 > mean50:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade58():
    # Buy the ticker that has had the largest percent decrease over the last 10 days (a potential mean reversion play)
    percent_changes = {}
    for ticker in tickers:
        percent_changes[ticker] = (prices[ticker][0] - prices[ticker][9]) / prices[ticker][9] * 100
    worst_ticker = min(tickers, key=lambda x: percent_changes[x])
    return [Trade(worst_ticker, 100)]

def trade59():
    # Sell the ticker that has had the largest percent increase over the last 10 days (a potential mean reversion play)
    percent_changes = {}
    for ticker in tickers:
        percent_changes[ticker] = (prices[ticker][0] - prices[ticker][9]) / prices[ticker][9] * 100
    best_ticker = max(tickers, key=lambda x: percent_changes[x])
    return [Trade(best_ticker, -100)]

def trade60():
    # Buy if the current price is above the 200-day mean and the 200-day mean is increasing (a potential long-term uptrend)
    trades = []
    for ticker in tickers:
        mean200 = np.mean(prices[ticker][:200])
        prev_mean200 = np.mean(prices[ticker][1:201])
        if prices[ticker][0] > mean200 and mean200 > prev_mean200:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade61():
    # Sell if the current price is below the 200-day mean and the 200-day mean is decreasing (a potential long-term downtrend)
    trades = []
    for ticker in tickers:
        mean200 = np.mean(prices[ticker][:200])
        prev_mean200 = np.mean(prices[ticker][1:201])
        if prices[ticker][0] < mean200 and mean200 < prev_mean200:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade62():
    # Buy if the stock's return is greater than the market's return over the last 5 days
    trades = []
    for ticker in tickers:
        stock_return = (prices[ticker][0] - prices[ticker][4]) / prices[ticker][4]
        market_return = (sum(prices[t][0] for t in tickers) - sum(prices[t][4] for t in tickers)) / sum(prices[t][4] for t in tickers)
        if stock_return > market_return:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade63():
    # Sell if the stock's return is less than the market's return over the last 5 days
    trades = []
    for ticker in tickers:
        stock_return = (prices[ticker][0] - prices[ticker][4]) / prices[ticker][4]
        market_return = (sum(prices[t][0] for t in tickers) - sum(prices[t][4] for t in tickers)) / sum(prices[t][4] for t in tickers)
        if stock_return < market_return:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade64():
    # Buy the stock with the highest relative strength compared to the market over the last 10 days
    relative_strengths = {}
    for ticker in tickers:
        stock_return = prices[ticker][0] / prices[ticker][9]
        market_return = sum(prices[t][0] for t in tickers) / sum(prices[t][9] for t in tickers)
        relative_strengths[ticker] = stock_return / market_return
    best_ticker = max(tickers, key=lambda x: relative_strengths[x])
    return [Trade(best_ticker, 100)]

def trade65():
    # Sell the stock with the lowest relative strength compared to the market over the last 10 days
    relative_strengths = {}
    for ticker in tickers:
        stock_return = prices[ticker][0] / prices[ticker][9]
        market_return = sum(prices[t][0] for t in tickers) / sum(prices[t][9] for t in tickers)
        relative_strengths[ticker] = stock_return / market_return
    worst_ticker = min(tickers, key=lambda x: relative_strengths[x])
    return [Trade(worst_ticker, -100)]

def trade66():
    # Buy stocks that have a higher Sharpe ratio than the market over the last 20 days
    trades = []
    market_returns = [(sum(prices[t][i] for t in tickers) / sum(prices[t][i+1] for t in tickers)) - 1 for i in range(19)]
    market_sharpe = np.mean(market_returns) / np.std(market_returns)
    for ticker in tickers:
        stock_returns = [(prices[ticker][i] / prices[ticker][i+1]) - 1 for i in range(19)]
        stock_sharpe = np.mean(stock_returns) / np.std(stock_returns)
        if stock_sharpe > market_sharpe:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade67():
    # Sell stocks that have a lower Sharpe ratio than the market over the last 20 days
    trades = []
    market_returns = [(sum(prices[t][i] for t in tickers) / sum(prices[t][i+1] for t in tickers)) - 1 for i in range(19)]
    market_sharpe = np.mean(market_returns) / np.std(market_returns)
    for ticker in tickers:
        stock_returns = [(prices[ticker][i] / prices[ticker][i+1]) - 1 for i in range(19)]
        stock_sharpe = np.mean(stock_returns) / np.std(stock_returns)
        if stock_sharpe < market_sharpe:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade68():
    # Buy stocks that have a higher beta than 1 (they move more than the market)
    trades = []
    market_returns = [(sum(prices[t][i] for t in tickers) / sum(prices[t][i+1] for t in tickers)) - 1 for i in range(49)]
    for ticker in tickers:
        stock_returns = [(prices[ticker][i] / prices[ticker][i+1]) - 1 for i in range(49)]
        beta = np.cov(stock_returns, market_returns)[0, 1] / np.var(market_returns)
        if beta > 1:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade69():
    # Sell stocks that have a lower beta than 1 (they move less than the market)
    trades = []
    market_returns = [(sum(prices[t][i] for t in tickers) / sum(prices[t][i+1] for t in tickers)) - 1 for i in range(49)]
    for ticker in tickers:
        stock_returns = [(prices[ticker][i] / prices[ticker][i+1]) - 1 for i in range(49)]
        beta = np.cov(stock_returns, market_returns)[0, 1] / np.var(market_returns)
        if beta < 1:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades

def trade70():
    # Buy stocks that have a higher percentage of up days than the market over the last 50 days
    trades = []
    market_up_days = sum(sum(prices[t][i] for t in tickers) > sum(prices[t][i+1] for t in tickers) for i in range(49))
    for ticker in tickers:
        stock_up_days = sum(prices[ticker][i] > prices[ticker][i+1] for i in range(49))
        if stock_up_days > market_up_days:
            quantity = random.randrange(1, 100)
            trades.append(Trade(ticker, quantity))
    return trades

def trade71():
    # Sell stocks that have a lower percentage of up days than the market over the last 50 days
    trades = []
    market_up_days = sum(sum(prices[t][i] for t in tickers) > sum(prices[t][i+1] for t in tickers) for i in range(49))
    for ticker in tickers:
        stock_up_days = sum(prices[ticker][i] > prices[ticker][i+1] for i in range(49))
        if stock_up_days < market_up_days:
            quantity = random.randrange(-100, -1)
            trades.append(Trade(ticker, quantity))
    return trades