def test_encode_bytearray():
helpers.test({
'type': parser.BINARY_EVENT,
'data': helpers.gen_bytearray(),
'id': 23,
'nsp': '/cool'
})
def main(arguments):
"""
Main function to run the stock market tester
"""
if arguments.download_data:
download_all_data()
print("Downloaded Data!")
# clean_data()
# print("Cleaned Data")
return
if arguments.download_stock is not None:
print(arguments.download_stock)
install_data(arguments.download_stock)
return
DAYS_OUT = 5
covid_data = get_covid_data()
model = Historic()
train_data, test_data = get_all_stocks(covid_data)
losses = []
for i in range(0, model.num_epochs):
train_loss = train(model, train_data, DAYS_OUT)
print("EPOCH {} training loss: {}".format(i, train_loss))
test_loss = test(model, test_data, DAYS_OUT)
print("EPOCH {} Test loss: {}".format(i, test_loss))
losses.append(test_loss)
visualize_loss(losses)
print("Last 10 Epochs Average MAPE: {}".format(sum(losses[-10:]) / 10))
sp_data = pd.read_csv("../data/^GSPC.csv")
sp_data = join(sp_data, covid_data)
sp_data = normalize(sp_data)
base_data = sp_data.iloc[:-DAYS_OUT]
base_data = tf.convert_to_tensor(base_data)
base_data = tf.expand_dims(base_data, 0)
labels = sp_data.iloc[DAYS_OUT:]
labels = labels["Adjusted Close"]
labels = labels.values.tolist()
# print(labels)
predictions = predict(model, base_data)
# print(len(predictions))
visualize_predictions(predictions, labels)
count = 0
for n in range(upper_bound):
if is_lychrel(n):
print n
count += 1
return count
def is_lychrel(n):
for i in range(1, 50):
#if n % 10 == 0:
# return False
n += reverse_number(n)
if is_palindrome(n):
return False
return True
test(reverse_number(4321), 1234)
test(is_lychrel(47), False)
test(is_lychrel(349), False)
test(is_lychrel(196), True)
test(is_lychrel(10677), True)
print find_lychrel_numbers(10000)
#create criterions
CE = Criterion.CrossEntropy()
MSE = Criterion.MSE()
CE_nn = nn.CrossEntropyLoss()
MSE_nn = nn.MSELoss()
#actual comparison
helpers.test(model_relu,
model_relu_nn,
opti,
opti_nn,
CE,
CE_nn,
"relu CE",
"relu nn CE",
repetitions=rep,
message="Relu vs Relu nn with crossentropy",
plots=plots,
show_plots=show_plots,
chrono=True,
training2=train_ref,
title_plots="comparison_CE_",
save_result_csv=save_csv,
filename="../results/csv/CE_comparison.csv")
helpers.test(model_relu,
model_relu_nn,
opti_mom,
opti_mom_nn,
CE,
CE_nn,
from math import factorial
from helpers import test
def ways(n, r):
diff = n - r
cancel = max(diff, r)
numerator = reduce(lambda a, b: a*b, [1] + range(cancel + 1, n + 1))
denominator = factorial(min(diff, r))
return numerator / denominator
def ways_greater_than(value, n_upper_bound):
ways_greater = 0
for n in range(1, n_upper_bound + 1):
for r in range(1, n + 1):
if ways(n, r) > value:
ways_greater += 1
return ways_greater
test(ways(23, 10), 1144066)
test(ways(10, 10), 1)
print ways_greater_than(1000000, 100)
def sum_pandigital():
# Don't double count any products
products = set([])
# 4-digit and 1-digit
for m1 in range(10**3, 10**4):
for m2 in range(10**0, 10**1):
p = m1 * m2
if is_expression_pandigital(m1, m2, p):
products.add(p)
print "%s * %s = %s" % (m1, m2, p)
# 3-digit and 2-digit
for m1 in range(10**2, 10**3):
for m2 in range(10**1, 10**2):
p = m1 * m2
if is_expression_pandigital(m1, m2, p):
products.add(p)
print "%s * %s = %s" % (m1, m2, p)
return sum(products)
test(is_expression_pandigital(39, 186, 7254), True)
test(is_expression_pandigital(33, 1216, 7254), False)
test(is_expression_pandigital(39, 186, 725), False)
test(is_expression_pandigital(1209, 7, 8463), False)
print sum_pandigital()
from typing import Callable
from helpers import test
def sum_digits(number: int) -> int:
sum = 0
for index, character in enumerate(reversed(list(str(number)))):
sum += int(character)
return sum
if __name__ == '__main__':
test(sum_digits, 10, 1234)
from helpers import test, is_palindrome
def is_dual_palindrome(n):
return is_palindrome(n) and is_palindrome(bin(n).lstrip('0b'))
def find_dual_palindromes(n):
return [i for i in range(n) if is_dual_palindrome(i)]
test(is_dual_palindrome(585), True)
test(is_dual_palindrome(9), True)
test(is_dual_palindrome(22), False)
test(is_dual_palindrome(16), False)
print sum(find_dual_palindromes(10**6))
def find_consecutive_prime_sum(upper_bound):
primes = primes_up_to(upper_bound)
sorted_primes = sorted(list(primes))
longest_sequence = []
for i in range(len(sorted_primes)):
sequence = []
k = 0
while (True):
if i + k >= len(sorted_primes):
break
sequence.append(sorted_primes[i + k])
if sum(sequence) > upper_bound:
break
if sum(sequence) in primes:
if len(sequence) > len(longest_sequence):
longest_sequence = copy(sequence)
k += 1
return longest_sequence
test(sum(find_consecutive_prime_sum(100)), 41)
test(sum(find_consecutive_prime_sum(1000)), 953)
print sum(find_consecutive_prime_sum(1000000))
from helpers import test
def pairwise_digits(num1: int, num2: int) -> str:
num1_s = str(num1)
num2_s = str(num2)
iterations = min(len(num1_s), len(num2_s))
result = ''
for i in range(iterations):
result += '1' if num1_s[i] == num2_s[i] else '0'
result += '0' * (abs(len(num1_s) - len(num2_s)))
return result
if __name__ == '__main__':
test(pairwise_digits, '0011', 1234, 2134)
test(pairwise_digits, '10010', 1213, 10435)
test(pairwise_digits, '1110', 1213, 121)
def get(self):
helpers.test()
self.render("signup.html")
def test_tie(winner, loser):
winner_hand = Hand([Card.parse_card(card) for card in winner])
loser_hand = Hand([Card.parse_card(card) for card in loser])
test(winner_hand == loser_hand, True)
def test_hand(cards, rank, rank_values):
hand = Hand([Card.parse_card(card) for card in cards])
test(hand.rank, rank)
test(hand.rank_values, rank_values)
distinct.setdefault(card.value, 0)
distinct[card.value] += 1
return distinct
def __lt__(self, other):
return self.rank < other.rank \
or (self.rank == other.rank and \
self.rank_values < other.rank_values)
def __eq__(self, other):
return self.rank == other.rank \
and self.rank_values == other.rank_values
test(Card.parse_card('6D').suit, Card.DIAMOND)
test(Card.parse_card('6D').value, 6)
test(Card.parse_card('KD').value, 13)
def test_hand(cards, rank, rank_values):
hand = Hand([Card.parse_card(card) for card in cards])
test(hand.rank, rank)
test(hand.rank_values, rank_values)
def test_win(winner, loser):
winner_hand = Hand([Card.parse_card(card) for card in winner])
loser_hand = Hand([Card.parse_card(card) for card in loser])
test(winner_hand > loser_hand, True)
def consecutive_digits(n):
digits = []
i = 1
while (True):
for d in str(i):
digits.append(int(d))
if len(digits) >= n:
return digits
i += 1
def evaluate_consecutive_expression():
digits = consecutive_digits(1000000)
expression = 1
for p in range(7):
expression *= digits[(10**p) - 1]
return expression
test(consecutive_digits(100)[11], 1)
test(consecutive_digits(100)[18], 4)
print evaluate_consecutive_expression()
from helpers import test, hexagonal_number, is_pentagonal_number, is_hexagonal_number
def find_pentagonal_and_hexagonal(lower_bound):
n = lower_bound + 1
while (True):
hn = hexagonal_number(n)
if is_pentagonal_number(hn):
return hn
n += 1
test(hexagonal_number(1), 1)
test(hexagonal_number(2), 6)
test(hexagonal_number(3), 15)
test(is_pentagonal_number(22), True)
test(is_pentagonal_number(24), False)
test(is_hexagonal_number(45), True)
test(is_hexagonal_number(46), False)
test(find_pentagonal_and_hexagonal(1), 40755)
print find_pentagonal_and_hexagonal(143)
n = str(n)
for i in range(1, 8):
sub_string = int(n[i:i + 3])
if sub_string % PRIMES[i - 1] != 0:
return False
return True
def find_sub_string_divisibility():
digits = [str(d) for d in range(10)]
numbers = []
for arrangement in permutations(digits):
if arrangement[0] == 0:
continue
n = int(''.join(arrangement))
if check_sub_string_divisibility(n):
numbers.append(n)
return numbers
test(check_sub_string_divisibility(1406357289), True)
test(check_sub_string_divisibility(1046357289), False)
print sum(find_sub_string_divisibility())
from helpers import test
def same_digits(n, m):
return sorted(str(n)) == sorted(str(m))
def find_same_digit_product(multiplications):
x = 1
while (True):
if all(same_digits(x, x * m) for m in range(2, multiplications + 1)):
return x
x += 1
test(same_digits(125874, 251748), True)
test(same_digits(425874, 257748), False)
test(find_same_digit_product(2), 125874)
print find_same_digit_product(6)
def get(self):
helpers.test()
self.render("signup.html")
while(True):
digits = digits[1:] + digits[0]
if digits == str(p):
return True
if int(digits) not in primes:
return False
def count_circular_primes(n):
circular_primes = []
primes = primes_up_to(n)
for prime in primes:
if is_circular_prime(prime, primes):
circular_primes.append(prime)
return len(circular_primes)
primes = primes_up_to(1000)
test(is_circular_prime(2, primes), True)
test(is_circular_prime(197, primes), True)
test(is_circular_prime(43, primes), False)
test(count_circular_primes(100), 13)
print count_circular_primes(10**6)
