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)