def test_p027():
pr27_coeff_list = common.sieve_erathosthenes(50)
pr27_prime_list = common.sieve_erathosthenes(3000)
assert p02x.consecutive_prime_count(1, 41, pr27_prime_list) == 40
assert p02x.consecutive_prime_count(-1, 41, pr27_prime_list) == 41
assert p02x.max_count_given_b(41, pr27_coeff_list, pr27_prime_list) == (-1, 41, 41)
assert p02x.max_count_combination(pr27_coeff_list, pr27_prime_list) == (-5, 47, 43)
def circular_primes_not_efficient_for_sparse_list(max_n):
prime_list = common.sieve_erathosthenes(max_n)
circ_prime_list = []
for p in prime_list:
circ_prime_list.extend(check_circular_prime_not_efficient_for_sparse_list(p, prime_list))
circ_prime_list.sort()
return circ_prime_list
def circular_primes(max_n):
"""Return list of all circular primes up to max_n."""
prime_list = common.sieve_erathosthenes(max_n)
circ_prime_list = []
for p in prime_list:
if is_circular_prime(p, prime_list):
circ_prime_list.append(p)
return circ_prime_list
def least_common_multiple_of_sequence(maxfactor):
product = 1
prime_list = common.sieve_erathosthenes(maxfactor)
for prime in prime_list:
prime_product = prime
while prime_product <= maxfactor:
product *= prime
prime_product *= prime
return product
def test_common():
# variables
ordered_list = list(range(-10, 10))
prime_list_10 = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
# power_digit_sum
common.power_digit_sum(2, 15) == 26
# index_in_ordered_list
assert common.index_in_ordered_list(-10, ordered_list) == ordered_list.index(-10)
assert common.index_in_ordered_list( -1, ordered_list) == ordered_list.index(-1)
assert common.index_in_ordered_list( 0, ordered_list) == ordered_list.index(0)
assert common.index_in_ordered_list( 9, ordered_list) == ordered_list.index(9)
assert common.index_in_ordered_list( 10, ordered_list) == -1
assert common.index_in_ordered_list(-11, ordered_list) == -1
# is_in_ordered_list
assert common.is_in_ordered_list(-10, ordered_list)
assert common.is_in_ordered_list( -1, ordered_list)
assert common.is_in_ordered_list( 0, ordered_list)
assert common.is_in_ordered_list( 9, ordered_list)
assert common.is_in_ordered_list( 10, ordered_list) is False
assert common.is_in_ordered_list(-11, ordered_list) is False
assert common.str_permutation(11, '0123') == '1320'
assert common.str_permutation(999999, '0123456789') == '2783915460'
# get_factors
assert common.get_factors(1) == [1]
assert common.get_factors(16) == [1, 2, 4, 8, 16]
# sieve_erathosthenes
assert common.sieve_erathosthenes(30) == prime_list_10
assert common.sieve_erathosthenes(30) != ordered_list
assert common.sieve_erathosthenes2(30) == prime_list_10
assert common.prime_list_mr(0, 30) == prime_list_10
# get_prime_factors
assert common.get_prime_factors(0, prime_list_10) == []
assert common.get_prime_factors(2, prime_list_10) == [2]
assert common.get_prime_factors(512, prime_list_10) == [2]
assert common.get_prime_factors(60, prime_list_10) == [2, 3, 5]
assert common.get_prime_factors(6469693230, prime_list_10) == prime_list_10
def truncatable_primes():
"""Return list of primes that are both left and right truncatable."""
prime_list = common.sieve_erathosthenes(1000000)
left_extend_primes = next_left_extend_prime('3', prime_list)
left_extend_primes.extend(next_left_extend_prime('7', prime_list))
right_extend_primes = next_right_extend_prime('2', prime_list)
right_extend_primes.extend(next_right_extend_prime('3', prime_list))
right_extend_primes.extend(next_right_extend_prime('5', prime_list))
right_extend_primes.extend(next_right_extend_prime('7', prime_list))
left_extend_primes.sort()
right_extend_primes.sort()
trunc_primes = []
for p in left_extend_primes[2:]:
if p in right_extend_primes:
trunc_primes.append(p)
# print(left_extend_primes)
# print(right_extend_primes)
# print(trunc_primes)
return trunc_primes
num_product *= fraction[0]
den_product *= fraction[1]
print(zfraction_list)
print(common.reduce_fraction(num_product, den_product))
elif problem_num == 34:
print()
print(factorial_sum_list(200))
print(factorial_sum_list())
elif problem_num == 35:
print(circular_primes(100))
print(len(circular_primes(1000000)))
elif problem_num == 36:
print(double_base_palindromes(1000))
print(double_base_palindromes(1000000))
elif problem_num == 37:
prime_list_10M = common.sieve_erathosthenes(10000000)
print(next_right_extend_prime('379', prime_list_10M))
print(next_left_extend_prime('797', prime_list_10M))
print(truncatable_primes())
elif problem_num == 38:
print(pandigital_concatenated_multiples())
elif problem_num == 39:
print()
p_list = integral_right_triangle_perimeters(100)
p_list.sort()
print(p_list)
p_list = integral_right_triangle_perimeters(1000)
max_count = 0
max_count_p = 0
for zprime in p_list:
zcount = p_list.count(zprime)
n = n // prime
ratio *= (prime-1)/prime
break
f = int(0.5 + n/ratio)
max_ratio = (n, f, ratio)
return max_ratio
# Problem 60-69 Checks
if __name__ == '__main__': # only if run as a script, skip when imported as module
problem_num = 69
if problem_num == 60:
print()
zprime_list = common.sieve_erathosthenes(10**5)
print('check_prime_concatenations(7, 109, zprime_list) = ', check_prime_concatenations(7, 109, zprime_list))
print('check_prime_concatenations(7, 11, zprime_list) = ', check_prime_concatenations(7, 11, zprime_list))
print('check_prime_pairs(1, [7, 109], zprime_list) = ', check_prime_pairs(1, [7, 109], zprime_list))
print('check_prime_pairs(4, [7, 109], zprime_list) = ', check_prime_pairs(4, [7, 109], zprime_list))
print('min_prime_pair_set(2) = ', min_prime_pair_set(2))
print('min_prime_pair_set(3) = ', min_prime_pair_set(3))
# print('min_prime_pair_set(4) = ', min_prime_pair_set(4))
print('min_prime_pair_set_mr(4) = ', min_prime_pair_set_mr(4))
print('min_prime_pair_set_mr(5) = ', min_prime_pair_set_mr(5))
elif problem_num == 61:
print()
zside_count = 3
for z in range(1, 4):
print('polygonal_number_list(', zside_count, ',', z, ') = ', generate_polygonal_number_list(zside_count, z))
print()
print(fibonacci_greater_than(10**z))
print(fibonacci_greater_than(10**999)[0])
elif problem_num == 26:
print()
for z in range(1, 11):
print(z, recurring_cycle(z))
zlongest = 0
zlongest_z = 1
for z in range(1, 1000):
zcycle_length = recurring_cycle(z)
if zlongest < zcycle_length:
zlongest = zcycle_length
zlongest_z = z
print(zlongest_z, zlongest)
elif problem_num == 27:
pr27_coeff_list = common.sieve_erathosthenes(1000)
pr27_prime_list = common.sieve_erathosthenes(1200000)
print(consecutive_prime_count(1, 41, pr27_prime_list))
print(consecutive_prime_count(-1, 41, pr27_prime_list))
print(consecutive_prime_count(-79, 1601, pr27_prime_list))
print(max_count_given_b(41, pr27_coeff_list, pr27_prime_list))
print(max_count_given_b(1601, pr27_coeff_list, pr27_prime_list))
print(max_count_combination(pr27_coeff_list, pr27_prime_list))
elif problem_num == 28:
pr28_dim = 5
print(pr28_dim, number_spiral_diagonal_sum(pr28_dim, 1, 1))
pr28_dim = 1001
print(pr28_dim, number_spiral_diagonal_sum(pr28_dim, 1, 1))
elif problem_num == 29:
pr29_list = [z for z in range(2, 6)]
print(distinct_powers(pr29_list))
