def prime_digit_replacement():
primes = et.prime_sieve(9999999)[25:]
chars = '0123456789'
for p in primes:
count = {}
for s in str(p):
if count.has_key(s):
count[s] += 1
else:
count[s] = 1
for key in count:
if count[key] > 1:
not_prime = 0
for c in chars:
sp = str(p)
np = int(sp.replace(key, c))
if len(str(np)) != len(sp):
not_prime += 1
continue
if not et.is_prime(np):
not_prime += 1
if not_prime > 3:
break
if not_prime < 3:
return p
def solve(target = 50000000):
primes = euler_tools.prime_sieve(int(math.sqrt(target)) + 1)
squares = []
cubes = []
fourths = []
for p in primes:
squares.append(p**2)
for p in primes:
num = p**3
if num > target:
break
cubes.append(num)
for p in primes:
num = p**4
if num > target:
break
fourths.append(num)
count = [0] * (target + 1)
for s in squares:
for c in cubes:
for f in fourths:
total = s + c + f
if total <= target:
count[total] = 1
return sum(count)
def goldbach_other():
primes = et.prime_sieve()
dsquares = [2*(x**2) for x in range(1, 10**5 + 1)]
for i in range(9, 10**5, 2):
if i in primes:
continue
if not check_match(i, primes, dsquares):
return i
def tm():
primes = et.prime_sieve()
i = 0
result = 1
while result * primes[i] < 1000000:
result *= primes[i]
i += 1
return result
def solve(max_value=10**5, target=5000):
primes = euler_tools.prime_sieve(max_value);
current = 2
while True:
ways = [0] * (current + 1)
ways[0] = 1
for i in range(0, len(primes)):
for j in range(primes[i], current + 1):
ways[j] += ways[j - primes[i]]
if ways[current] >= target:
return current
#for i in range(len(ways)):
#if ways[i] == target:
#return i
current += 1
def consecutive_prime_sum():
primes = et.prime_sieve(1000000)
max_count = 0
found_prime = 0
for i in range(len(primes)):
for j in range(i + 1, len(primes)):
if j - i < max_count:
continue
sp = sum(primes[i:j])
if sp >= 1000000:
break
if sp in primes:
max_count = j - i
found_prime = sp
return found_prime, max_count
def prime_permuts():
def get_length_4_primes(primes):
return [x for x in primes if len(str(x)) == 4]
def build_match_dict(primes):
m = {}
for i in primes:
si = str(i)
if len(si) != 4:
continue
key = ''.join(sorted(list(si)))
if not m.has_key(key):
m[key] = list()
m[key].append(i)
t = {}
for k in m:
if len(m[k]) >= 3:
t[k] = m[k]
return t
def equal_diffs(nums):
d = {}
for i in range(len(nums)):
for j in range(i + 1, len(nums)):
diff = nums[j] - nums[i]
if not d.has_key(diff):
d[diff] = set()
d[diff].add(i)
d[diff].add(j)
ed = {}
for k in d:
if len(d[k]) < 3:
continue
l = list()
for i in d[k]:
l.append(nums[i])
ed[k] = l
return ed
primes = get_length_4_primes(et.prime_sieve(10000))
matches = build_match_dict(primes)
l = list()
for key in matches:
nums = matches[key]
diff_dict = equal_diffs(nums)
l.append(diff_dict)
return l
def prime_pair_sets():
primes = et.prime_sieve(10**4)
prime_count = len(primes)
min_sum = -1
for a in range(prime_count):
print a
for b in range(a+1, prime_count):
if not test_primes((primes[a], primes[b])):
continue
for c in range(b+1, prime_count):
if not test_primes((primes[a], primes[b], primes[c])):
continue
for d in range(c+1, prime_count):
if not test_primes((primes[a], primes[b], primes[c], primes[d])):
continue
for e in range(d+1, prime_count):
prime_set = primes[a], primes[b], primes[c], primes[d], primes[e]
if test_primes(prime_set):
if min_sum == -1 or min_sum > sum(prime_set):
min_sum = sum(prime_set)
print min_sum
return min_sum
