@author: Home """ from eulerTools import isPrime from eulerTools import sieve_for_primes_to from datetime import datetime startTime = datetime.now() hoog = 10000 def digitsum(n): return sum([int(c) for c in str(n)]) primes = sieve_for_primes_to(hoog) primes.remove(2) arr = [0 for i in xrange(hoog)] d = {} for i in range(len(primes)): d[primes[i]] = i def func(): idx = 0 m = len(primes) while True: p = primes[idx] cdx = idx + 1
# -*- coding: utf-8 -*- """ Created on Tue Jul 11 22:46:41 2017 @author: Home """ from eulerTools import sieve_for_primes_to from datetime import datetime startTime = datetime.now() high = 50000000 max_val = [] p_list = sieve_for_primes_to(high) p_list = p_list[1:] lst = [] res = 2 #[2, 2] and [2, 2, 2, 2] for p in p_list: if (p + 1) % 4 == 0: res += 1 idx = 0 while 4 * p_list[idx] < high: #could be optimized with binary search idx += 1 #but only small gain relative to total res += idx idx = 0 while 16 * p_list[idx] < high:
# -*- coding: utf-8 -*- """ Created on Fri Apr 14 16:08:02 2017 @author: Home """ #See problem 129 from math import gcd from eulerTools import primeFactor, eulerPhi, sieve_for_primes_to from datetime import datetime primes = set(sieve_for_primes_to(int(1e6))) idx = 0 def order_of_10(n): nt = eulerPhi(n) primes = set(primeFactor(nt)) order_10_m = nt for p in primes: while order_10_m % p == 0 and pow(10, order_10_m, n) == 1: order_10_m //= p if pow(10, order_10_m, n) != 1: order_10_m *= p return order_10_m startTime = datetime.now()
""" Created on Tue Jul 18 15:47:15 2017 @author: Home """ from math import sqrt from eulerTools import sieve_for_primes_to from datetime import datetime from timeit import default_timer as timer startTime = datetime.now() start = timer() res = 0 primes = sieve_for_primes_to(150 * 10**6) diffs = [2, 4, 2, 4, 14] for idx in range(len(primes) - 5): flag = True for bdx in range(5): if primes[idx + bdx + 1] - primes[idx + bdx] != diffs[bdx]: flag = False break if flag: if sqrt(primes[idx] - 1) == int(sqrt(primes[idx] - 1)): res += int(sqrt(primes[idx] - 1)) #10 #315410
d1 = {} for c in str(n1): d1[c] = 0 for c in str(n1): d1[c] += 1 d2 = {} for c in str(n2): d2[c] = 0 for c in str(n2): d2[c] += 1 return d1 == d2 hoog = int((pow(10, 7))) primes = sieve_for_primes_to( hoog / 10) #under assumption that it have no prime-factors #below 10, which whould increate the quotient significantly m = len(primes) min_n = float("inf") min_phi = 1 k = len(primes) #Solution cannot be prime as phi(p) = p-1 for p prime, thus not a permutation for idx in range(k - 1): if (primes[idx] * primes[idx + 1]) > hoog: continue if (primes[idx] * min_phi) > min_n * (primes[idx] - 1): break for bdx in range(idx + 1, k): new_n = primes[idx] * primes[bdx]
""" Created on Tue Aug 23 20:08:16 2016 @author: Home """ #Sorting the numbers based on radicals for 1 <= n <= 100000 #Using a memoized recursive primefactorization. from datetime import datetime startTime = datetime.now() from math import sqrt from eulerTools import sieve_for_primes_to primes = set(sieve_for_primes_to(100000)) primes.add(1) mem_dic = {} for p in primes: mem_dic[p] = {p} def prod(arr): res = 1 for el in arr: res *= el return res def primeFactor(n): if n in mem_dic:
if not isPrime(m + 7, low_prime): return False, 7 if not isPrime(m + 9, low_prime): return False, 9 if not isPrime(m + 13, low_prime): return False, 13 if not isPrime(m + 27, low_prime): return False, 27 return True startTime = datetime.now() start = timer() high_prime = 19 primes = sieve_for_primes_to(high_prime + 1) mod_classes = [] temp_mod_classes = [] additions = [1, 3, 7, 9, 13, 27] for idx, prime in enumerate(primes): mod_list = [] for k in range(prime): flag = True for add in additions: if (k*k + add)%prime == 0: flag = False break if flag:
# -*- coding: utf-8 -*- from eulerTools import sieve_for_primes_to import copy from datetime import datetime startTime = datetime.now() arr = [0 for i in xrange(1000000)] primes = sieve_for_primes_to(1000000) for p in primes: arr[p] = 1 def binGen(lijst, plek): if plek >= len(lijst[0]): return for idx in range(len(lijst)): sub = lijst[idx] other = copy.copy(sub) sub[plek] = 0 other[plek] = 1 lijst.append(other) binGen(lijst, plek + 1) n = 10 flag = False toDo = [1 for i in range(1000000)]
""" #most of the time is spent on handling primes, not finding combinations(80ms) #total time: 10.3s from eulerTools import sieve_for_primes_to from datetime import datetime def complement(s): return const.difference(s) #note: 123456789 or a permuation is not prime startTime = datetime.now() primes = sieve_for_primes_to(98765432 + 1) prime_arr = [] prime_d = {} for p in primes: p_str = str(p) if '0' in p_str: continue p_set = set(p_str) if len(p_set) == len(p_str): p_tuple = tuple(sorted(list(p_set))) if p_tuple in prime_d: prime_d[p_tuple] += 1 else: prime_d[p_tuple] = 1
#time: 15ms from eulerTools import sieve_for_primes_to from datetime import datetime from timeit import default_timer as timer def binSearch(arr, a, b, target): if a == b: return a mid = (a + b) // 2 val = 2 * (2 * mid + 1) * arr[mid] if target <= val: return binSearch(arr, a, mid, target) else: return binSearch(arr, mid + 1, b, target) startTime = datetime.now() start = timer() max_prime = 300000 primes = sieve_for_primes_to(max_prime) sprimes = [primes[idx] for idx in range(0, len(primes), 2)] resIdx = binSearch(sprimes, 0, len(sprimes), 10**10) print("Result =", 2 * resIdx + 1) print(datetime.now() - startTime) print((timer() - start) * 1000) #time: 15ms
def ord10(p): n = 2 p9 = 9 * p target = 6 * (p - 1) divs = primeFactor_listset(target) for n in divs: if target % n == 0: while (target % n == 0) and (pow(10, target // n, p9) == 1): target //= n return target startTime = datetime.now() p_list = sieve_for_primes_to(100000) res = sum(p_list[:3]) p_list = p_list[3:] check_list = [[], [2], [5], [2, 5]] for p in p_list: z = ord10(p) while z % 2 == 0: z //= 2 while z % 5 == 0: z //= 5 if z != 1: res += p print("Result =", res)
# -*- coding: utf-8 -*- from datetime import datetime startTime = datetime.now() from eulerTools import sieve_for_primes_to max_size = 300 max_n = 300 nArray = [0 for i in range(max_size + 1)] nArray[0] = 1 over = sieve_for_primes_to(max_n) oldArr = nArray for n in over: for idx in range(n, max_size): nArray[idx] = nArray[idx] + nArray[idx - n] def binFind_g(arr, idx, n, el): if arr[idx] <= el: return binFind_g(arr, (n + idx + 1) / 2, n, el) if arr[idx] > el and arr[ idx - 1] > el: #under assumption element will not be at index 0 return binFind_g(arr, idx / 2, idx, el) else: return idx print "smallest number is: " + str(binFind_g(nArray, 0, len(nArray) - 1, 5000))
# -*- coding: utf-8 -*- """ Created on Sun May 21 19:36:52 2017 @author: Home """ from eulerTools import isPrime, sieve_for_primes_to from datetime import datetime startTime = datetime.now() counter = 0 res = 0 primes = sieve_for_primes_to(int(2e5)) primes.remove(2) primes.remove(5) m = 10**9 two_count = 9 five_count = 9 for p in primes: mod_chain_l = 1 mod_ten_power = 1 temp_mod = 1 while temp_mod != 0: mod_ten_power = (10 * mod_ten_power) % p temp_mod = (temp_mod + mod_ten_power) % p mod_chain_l += 1
# -*- coding: utf-8 -*- """ Created on Sat May 20 17:02:59 2017 @author: Home """ from eulerTools import sieve_for_primes_to from datetime import datetime startTime = datetime.now() high = int(1e6) primes = sieve_for_primes_to(high) dtriangle_set = set() dtriangle_set.add(2) max_n = 1 max_dtriangle = 2 def isDTriangle(n): global max_dtriangle, max_n if max_dtriangle < n: while max_dtriangle < n: max_n += 1 max_dtriangle = max_n * (max_n + 1) dtriangle_set.add(max_dtriangle) return n in dtriangle_set
#number, the parity of the corners will be either both even, or the curent #corner cell one parity, and the neighbouring parities opposing. We now have #2 odd and 2 even differences, giving at most 2 prime differences. # #time: 100ms from eulerTools import isPrime, sieve_for_primes_to from datetime import datetime from timeit import default_timer as timer startTime = datetime.now() start = timer() max_prime = int(1e6) primes = set(sieve_for_primes_to(max_prime)) def prime(n): if n > max_prime: return isPrime(n) return n in primes idx = 0 k = 0 target = 2000 resSet = set() while idx < target: p_1 = 6*(k+1) - 1 if prime(p_1): resSet.add(p_1)