@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)