groups_that_are_prime += 1
sub_primes.append(right)
sub_primes = list(set(sub_primes))
m = len(sub_primes)
if m >= n:
all_orders_are_prime = True
print(sub_primes)
for i in range(m):
for j in range(m):
if i == j:
continue
test_prime = int(
str(sub_primes[i]) + str(sub_primes[j]))
if test_prime >= 1000000 and not euler.is_prime(
test_prime, 32
) or test_prime < 1000000 and not sieve[test_prime]:
all_orders_are_prime = False
print(' {} is not prime.'.format(test_prime))
break
if not all_orders_are_prime:
break
if all_orders_are_prime:
print(sub_primes)
return sum(sub_primes)
"""
doesn't find anything... f**k this problem in particular
"""
euler.time_it(prime_pair_sets)
"""
The 5-digit number, 16807=7^5, is also a fifth power. Similarly, the 9-digit number, 134217728=8^9, is
a ninth power.
How many n-digit positive integers exist which are also an nth power?
"""
import eulerlib as euler
import math
def powerful_digit_counts():
count = 0
for n in range(1, 100):
lower = 10**(n - 1)
upper = 10**n
for k in range(1, 10):
if lower <= k**n < upper:
print('{}^{}={}'.format(k, n, k**n))
count += 1
return count
euler.time_it(powerful_digit_counts)
import eulerlib
coins = [1, 2, 5, 10, 20, 50, 100, 200]
memo = {}
def coin_sums(t, c=7):
if c <= 0 or t <= 0:
return 1
if (t, c) in memo.keys():
return memo[(t, c)]
res = sum(
[coin_sums(t - i * coins[c], c - 1) for i in range(t // coins[c] + 1)])
memo[(t, c)] = res
return res
eulerlib.time_it(coin_sums, [200])
return res
def pdr(max_n):
result = {}
memo = {}
for i in range(13, max_n):
if not sieve[i] and i % 11 != 0:
continue
print('Testing: {}'.format(i))
istr = str(i)
perms = perm(lib.digits(istr), len(istr))
for p in perms:
if p in memo.keys():
continue
memo[p] = True
count = 0
for j in range(0, 10):
if j == 0 and p[0] == '*':
continue
pnum = int(p.replace('*', str(j)))
if sieve[pnum]:
count += 1
result[p] = count
if count == 8:
print('Smallest prime with eight prime value family is {} with permutation {}'.format(i, p))
exit(0)
lib.time_it(lambda: pdr(len(sieve)))
L = list(range(1, n + 1))[::-1]
prev_L = None
while L != prev_L:
prev_L = list(L)
if is_prime(eulerlib.digits_to_int(L), 10):
return L
L = previous_permutation(L)
return None
"""
The solution is
max { LargestPandigitalPrime(n) | 1 <= n <= 9 }
which gives
"""
def search_pandigital_primes():
P = []
for n in range(1, 9 + 1):
p = largest_pandigital_prime(n)
if p is not None:
P.append(eulerlib.digits_to_int(p))
print('N={} => PD({}) = {}'.format(n, n, eulerlib.digits_to_int(p)))
return max(P)
eulerlib.time_it(search_pandigital_primes)
import eulerlib
def triangular_pentagonal_hexagonal():
i = 144
hexagonal = eulerlib.hexagonal_number(i)
while not (eulerlib.is_pentagonal_number(hexagonal)
and eulerlib.is_triangle_number(hexagonal)):
i += 1
hexagonal = eulerlib.hexagonal_number(i)
return hexagonal
eulerlib.time_it(triangular_pentagonal_hexagonal)
Gives an odd composite number c, rewrite the
number in the form of p + 2a^2 (a prime plus two times a square).
Return False if this is not possible.
:param p:
:return:
"""
for a in range(1, int(math.sqrt(c / 2)) + 1):
if sieve[c - 2 * a**2]:
return c - 2 * a**2, a
return False, False
def find_contradiction():
N = 10000
primes = eulerlib.prime_sieve(N)
# For all odd composite numbers
for i in range(3, N, 2):
if primes[i]:
continue
# Factor into a prime plus a square
p, a = factor_goldbach(i, primes)
# Not factorized?
if not p:
# Return solution
return i
print('{} = {} + 2^{}'.format(i, p, a))
eulerlib.time_it(find_contradiction)
import eulerlib
def digit_powers(n):
numbers = [
i for i in range(2, 9**n * n + 1)
if sum(map(lambda x: x**n, eulerlib.digits(i))) == i
]
print('Numbers found: {}'.format(numbers))
return sum(numbers)
eulerlib.time_it(digit_powers, [5])
"""
Find the sum of digits in the numerator of the 100th convergent of the continued fraction for e.
"""
from fractions import ContinuedFraction
import math
from eulerlib import digits, time_it
def convergents_of_e():
an = [2]
for k in range(1, 34):
an += [1, 2 * k, 1]
cf = ContinuedFraction(an)
return sum(digits(cf.pn(99)))
time_it(convergents_of_e)
def word_to_number(word):
return sum([letter_to_number(c) for c in word])
def coded_triangle_numbers(words):
numbers_to_test = list(map(word_to_number, words))
print('Maximum triangle number: {}'.format(max(numbers_to_test)))
triangle_number_sieve = eulerlib.triangle_number_sieve(
max(numbers_to_test))
return sum([1 for n in numbers_to_test if triangle_number_sieve[n]])
def coded_triangle_numbers_quadratic(words):
numbers_to_test = list(map(word_to_number, words))
return sum([1 for n in numbers_to_test if eulerlib.is_triangle_number(n)])
def coded_triangle_numbers_quadratic_inline(words):
numbers_to_test = list(map(word_to_number, words))
return sum([
1 for n in numbers_to_test
if ((math.sqrt(1 + 8 * n) - 1) / 2).is_integer()
])
eulerlib.time_it(coded_triangle_numbers, [problem_data])
eulerlib.time_it(coded_triangle_numbers_quadratic, [problem_data])
eulerlib.time_it(coded_triangle_numbers_quadratic_inline, [problem_data])
def consecutive_prime_sum():
sieve = eulerlib.prime_sieve(1000000) # takes ~0.5 sec to load
primes = [i for i, v in enumerate(sieve) if v]
max_s = 0
max_len = 0
max_i = 0
# 551 = number of primes needed when the sum >1 M
# 551 = len([i for i, v in enumerate(eulerlib.prime_sieve(1000000//50//5)) if v])
number_of_primes_till_sum_1m = 551
for i in range(0, number_of_primes_till_sum_1m):
for k in range(i, number_of_primes_till_sum_1m, 2):
if k * primes[i] > 1000000:
break
s = sum(primes[i:k + 1])
if s > 1000000:
break
if sieve[s] and k - i > max_len:
max_s = s
max_len = k - i
max_i = i
print('Number of terms: {}'.format(max_len))
print('Sum starts at n: {}'.format(max_i))
print('Sum starts at P: {}'.format(primes[max_i]))
return max_s
eulerlib.time_it(consecutive_prime_sum)
lowest_nums = []
lowest_denoms = []
for den in range(10, 100):
if den % 10 == 0:
continue
for num in range(10, den):
num_digits = eulerlib.digits(num)
den_digits = eulerlib.digits(den)
if num % 10 == 0:
continue
digits_intersection = list(set(num_digits) & set(den_digits))
if len(digits_intersection) > 0:
num_digits.remove(digits_intersection[0])
den_digits.remove(digits_intersection[0])
num_lct = eulerlib.digits_to_int(num_digits)
den_lct = eulerlib.digits_to_int(den_digits)
cancelled_fraction = num_lct / den_lct
fraction = num / den
if fraction == cancelled_fraction:
lowest_nums.append(num_lct)
lowest_denoms.append(den_lct)
print('{} / {} = {} / {}'.format(num, den, num_lct, den_lct))
num_prod = eulerlib.product(lowest_nums)
den_prod = eulerlib.product(lowest_denoms)
gcd = eulerlib.gcd(num_prod, den_prod)
return den_prod / gcd
eulerlib.time_it(digit_cancelling_fractions)
for j in range(1, n):
for k in range(1, j + 1):
px = lt[j]
py = lt[k]
if px == py:
continue
d = abs(px - py)
if eulerlib.is_pentagonal_number(px + py) \
and eulerlib.is_pentagonal_number(d) \
and d < min_d:
min_d = d
return min_d
def pentagon_numbers2():
for n in range(1, 1000):
for i in range(1, n):
c = (3 * i**2 + 6 * n * i - 2 * n - i) * 2
_, x2 = quadratic.solve(3, -1, -2 * c)
if eulerlib.is_number(x2) and x2.is_integer():
print(c, x2)
# check if the sum is pentagonal too
# ...
# Calculate difference directly P(k) = P(n + i) - P(n), and check if P(k) is pentagonal.
# Then check if P(n + i) + P(n) is pentagonal too. That's it, in theory...
eulerlib.time_it(pentagon_numbers2)
#eulerlib.time_it(pentagon_numbers)
import eulerlib as lib
def count_lychrel(n):
count = 0
for k in range(n):
for _ in range(50):
k = k + int(str(k)[::-1])
strk = str(k)
if strk == strk[::-1]:
break
count += 1
return count
lib.time_it(lambda: count_lychrel(10000))
rcounts = {r:ranks.count(r) for r in ranks}.items()
# score = (2, 1, 1, 1)
# ranks = (3, 11, 5, 4)
score, ranks = zip(*sorted((v, k) for k, v in rcounts)[::-1])
if len(score) == 5:
straight = (ranks[0] - ranks[-1]) == 4
flush = len({s for (_, s) in cards}) == 1
if straight and flush: score = (5, )
elif not straight and flush: score = (3, 1, 3)
elif straight: score = (3, 1, 2)
# result = ((2, 1, 1, 1), (3, 11, 5, 4))
return score, ranks
# golfed version - 280 chars, a tweet
def f(H):
z,s,L=zip,sorted,len
R,U=z(*s([("23456789TJQKA".index(r),s)for r,s in H.split()])[::-1])
S,R=z(*s((v,k)for k,v in{r:R.count(r)for r in R}.items())[::-1])
c,s,f=L(S)==5,R[0]-R[-1]==4,L(set(U))==1
return(((1,),(3,1,3)),((3,*S),(5,)))[s][f]if c else S,R
def poker_hands():
total_wins = 0
with open('poker.txt', 'r') as file:
for line in file:
if f(line[:14]) > f(line[15:]):
total_wins += 1
return total_wins
time_it(poker_hands)
print('Decimal as float: {}'.format(1 / denominator_with_largest_cycle))
return denominator_with_largest_cycle
def reciprocal_cycles_primes():
denominator_with_largest_cycle = 0
largest_cycle = 0
longest_decimal = ""
primes = [i for i, v in enumerate(eulerlib.prime_sieve(1000)) if v]
for d in primes:
decimal, is_cyclic, cycle_length = fraction_to_decimal(1, d)
if is_cyclic and cycle_length > largest_cycle:
denominator_with_largest_cycle = d
largest_cycle = cycle_length
longest_decimal = decimal
print('Denominator with largest cycle: {}'.format(
denominator_with_largest_cycle))
print('Cycle length: {}'.format(largest_cycle))
print('Decimal as string: {}'.format(longest_decimal))
print('Decimal as float: {}'.format(1 / denominator_with_largest_cycle))
return denominator_with_largest_cycle
eulerlib.time_it(reciprocal_cycles)
eulerlib.time_it(reciprocal_cycles_primes)
Returns true if A, B and C are permutations of each other.
:param A:
:param B:
:param C:
:return:
"""
return set(A) == set(B) == set(C)
def prime_permutations():
N = 10000
S = eulerlib.prime_sieve(N)
P = [p for p in eulerlib.sieve_to_list(S) if 1000 < p < 9999]
print('p1 p2 p3 d')
print('------------------------')
for p1 in P:
d = 1
while p1 + 2 * d < N:
p2 = p1 + d
p3 = p2 + d
if S[p1] and S[p2] and S[p3] and is_permutation3(
eulerlib.digits(p1), eulerlib.digits(p2),
eulerlib.digits(p3)):
print(p1, p2, p3, d)
break
d += 1
eulerlib.time_it(prime_permutations)
import eulerlib
def digit_factorials():
result = 0
factorials = [eulerlib.factorial(i) for i in range(10)]
for n in range(4 * eulerlib.factorial(8) + 1):
digits_of_n = [int(i) for i in str(n)]
n_fact = sum([factorials[digit] for digit in digits_of_n])
if n == n_fact:
print(n)
result += n_fact
return result - 3
eulerlib.time_it(digit_factorials)
import eulerlib
import math
def double_base_palindromes():
palindromes = eulerlib.palindromes(1, 1e6 + 1)
result = []
for p in palindromes:
p_bin = eulerlib.to_binary_string(p)
if eulerlib.is_palindrome(p_bin):
print('{} = {}'.format(p, p_bin))
result.append(p)
return sum(result)
eulerlib.time_it(double_base_palindromes)
"""
Returns the product of a list of numbers.
:param numbers:
:return:
"""
p = 1
for x in numbers:
p *= x
return p
def ccr(x):
return sum([9 * 10**i * (i + 1) for i in range(x)])
def champernownes_digit(d):
k = 0
while ccr(k) < d:
k += 1
lower = ccr(k - 1)
index = (d - lower) / k
res = index + 10**(k - 1) - 1
res_ceil = math.ceil(res)
diff = res_ceil - res
sub = int((1 - diff - 1 / k) * k)
return str(res_ceil)[sub]
eulerlib.time_it(
lambda: product(map(int, [champernownes_digit(10**i) for i in range(7)])))
eulerlib.time_it(lambda: champernownes_digit(10**100)) # the googelth digit.
import eulerlib
def circular_primes():
sieve = eulerlib.prime_sieve(1000000)
primes = [i for i, v in enumerate(sieve) if v]
result = 0
for p in primes:
is_circular_prime = True
prime_c = eulerlib.digits(p)
for _ in range(len(prime_c) - 1):
prime_c = eulerlib.shift(prime_c)
if not sieve[eulerlib.digits_to_int(prime_c)]:
is_circular_prime = False
break
if is_circular_prime:
print(p)
result += 1
return result
eulerlib.time_it(circular_primes)
def pandigital_products():
res = 0
memo = []
bound = 10000
set_of_1_to_9 = set(range(1, 10))
for a in range(2, bound):
log10a = math.log(a, 10)
inner_exp = 7/2 - log10a
if not eulerlib.is_unique_string(str(a)):
continue
lower_bound_for_b = int(10**inner_exp)
for b in range(lower_bound_for_b, 10*lower_bound_for_b):
log10b = math.log(b, 10)
log10c = log10a + log10b
log_digits = int(log10a + log10b + log10c)
if log_digits != 7:
continue
c = a * b
mmi = int(str(a) + str(b) + str(c))
digits_of_mmi = eulerlib.digits(mmi)
if c not in memo and set(digits_of_mmi) == set_of_1_to_9:
print('{} x {} = {} ({})'.format(a, b, c, mmi))
res += c
memo.append(c)
return res
eulerlib.time_it(pandigital_products)
import eulerlib
def non_abundant_sums(n):
sieve = eulerlib.sum_of_proper_divisors_sieve(n + 1)
checked = {x: False for x in range(1, n + 1)}
abundant_numbers = [x for x in range(1, n + 1) if sieve[x] > x]
length = len(abundant_numbers)
for i in range(length):
for j in range(i, length):
s = abundant_numbers[i] + abundant_numbers[j]
if s <= n:
checked[s] = True
return sum([k for k, v in checked.items() if not v])
eulerlib.time_it(non_abundant_sums, args=[28123]) # answer is 4179871
# Check if a and n are co-prime.
if gcd(n, a) != 1:
return False
# Fermat's little theorem
if modpow(a, n - 1, n) != 1:
return False
k -= 1
return True
def sp():
k = 1
primes = 0
while (True):
p = 4 * k * k + 4 * k + 1
for j in range(4):
q = p - 2 * j * k
if is_prime(q, 20):
primes += 1
rat = primes / (4 * k + 1)
if rat <= 0.1:
return 2 * k + 1
k += 1
pe.time_it(lambda: sp())
# Solution is 26241
# Executed in 6.178759 seconds
import eulerlib as el
def pandigital_multiples():
pandigitals = []
for i in range(1, 10000):
digits = el.digits(i)
j = 2
while len(digits) < 9:
digits += el.digits(i * j)
j += 1
if len(digits) == 9 and el.is_pandigital_to_n(digits, 9):
print('Pandigital: {}'.format(digits))
pandigitals.append(el.digits_to_int(digits))
return max(pandigitals)
el.time_it(pandigital_multiples)
