You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

725 lines
29 KiB

# 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