""" Prime generating integers Consider the divisors of 30: 1,2,3,5,6,10,15,30. It can be seen that for every divisor d of 30, d+30/d is prime. Find the sum of all positive integers n not exceeding 100 000 000 such that for every divisor d of n, d+n/d is prime. """ __author__ = 'julenka' from primes import primesfrom2to import math max_value = 100000000 primes = set(primesfrom2to(max_value * 2)) valid = [] result = 0 def test_number(n): for i in xrange(1, int(math.sqrt(n)) ): if n % i == 0: if n / i + i in primes: return True return False for i in xrange(1, max_value): if test_number(i): result += i
divisors.append(str(divisor)) return divisors if __name__ == "__main__": import math T = int(sys.stdin.readline()) #number of test cases for i in xrange(1,T+1): N,J = sys.stdin.readline().split(' ') N = int(N) J = int(J) print 'Case #%d:'%i min_value = 2**(N-1) +1 #First and last digits are 1 max_value = 2**N - 1 #All 1's #Generate primes MAX_PRIME = 100000 primes = primesfrom2to(MAX_PRIME) j = 0 for candidate in xrange(min_value,max_value,2): candidate_binary = bin(candidate)[2:] divisors = check_coinjam(candidate_binary,primes) if divisors: print candidate_binary, ' '.join(divisors) j+=1 if j == J: #we are done break
from primes import primesfrom2to import math import time primes = primesfrom2to(10**7) # 1. Find all primitive pytagorean triples # 2. Check if their line lengths are unique - if not remove them # 3. scale them up and add to the sum def generate_prime_products(p_id, prev_product, upper_product_limit, lower_product_limit, exception_primes=None): # yield [] global primes if prev_product == 1: yield 1, [] for current_p_id in range(p_id, len(primes) + 1): if prev_product * primes[current_p_id] > upper_product_limit: return if exception_primes and primes[current_p_id] in exception_primes: continue k = 1 current_product = prev_product * (primes[current_p_id]**k)
Find the value of n ≤ 1,000,000 for which n/φ(n) is a maximum. FORMULA: φ(n) = n * PRODUCT[unique prime factors p of n] ( 1 - 1/p) """ from primes import primesfrom2to from collections import defaultdict MAX_VAL = 10**6 # n->set(divisors) # divisors is set of unique prime factors only divisor_map = {} primes = [1] + list(primesfrom2to(MAX_VAL)) # print primes print "getting unique prime divisors..." for i in xrange(1, MAX_VAL + 1): if i % 10**3 == 0: print i divisor_map[i] = set() j = 1 while j < len(primes) and primes[j] <= i: if i % primes[j] == 0: divisor_map[i].add(primes[j]) other = i / primes[j] divisor_map[i] = divisor_map[i].union(divisor_map[other]) break
from primes import primesfrom2to import math max_sum = 50*(10**6) primes = primesfrom2to(int(math.sqrt(max_sum))) print("Min prime = ", primes[0]) print("Max prime = ", primes[-1]) # some caching for speedup primes_squared = [] lim = max_sum - (2**3 + 2**4) for p in primes: pp = p*p if pp > lim: break primes_squared.append(pp) primes_cubed = [] lim = max_sum - (2**2 + 2**4) for p in primes: ppp = p**3 if ppp > lim: break primes_cubed.append(ppp) primes_fourth = [] lim = max_sum - (2**2 + 2**3) for p in primes: pppp = p**4 if pppp > lim: break primes_fourth.append(pppp)
from primes import primesfrom2to import time import itertools start = time.time() presumed_length = 4 # presumed max length of the primes primes = primesfrom2to(10**(2 * presumed_length)) primes = set([str(p) for p in primes if p > 10**presumed_length]) possible_primes = set([str(p) for p in primesfrom2to(10**presumed_length)]) print("Calculated primes in ", time.time() - start) # 5 primes # for every of these 5 primes: # - there exist at least 5 other primes which end with them # - there exist at least 5 other primes which start with them total_possible_pairs = [] # for p in possible_primes: # possible_pairs = [] # # p must have 8 possible pairs to be a possible prime # for pr in primes: # if len(pr) > len(p): # if pr.endswith(p) or pr.startswith(p): # c = pr.replace(p, "") # if c in primes: # possible_pairs.append((p,c))
42 21 22 23 24 25 26 43 44 45 46 47 48 49 It is interesting to note that the odd squares lie along the bottom right diagonal, but what is more interesting is that 8 out of the 13 numbers lying along both diagonals are prime; that is, a ratio of 8/13 ~= 62%. If one complete new layer is wrapped around the spiral above, a square spiral with side length 9 will be formed. If this process is continued, what is the side length of the square spiral for which the ratio of primes along both diagonals first falls below 10%? """ __author__ = "Julia Schwarz" from primes import primesfrom2to primes = set(primesfrom2to(10**9)) pct = 1.0 level = 1 diagonals = [1] num_primes = 0 print "level, side_length, n_diagonals, n_primes, pct" while pct >= 0.1: side_length = 2 * level + 1 square = side_length ** 2 for i in xrange(4): corner = square - (side_length - 1) * i diagonals.append(corner) if corner in primes: num_primes += 1 pct = float(num_primes) / len(diagonals)
""" Prime power triples The smallest number expressible as the sum of a prime square, prime cube, and prime fourth power is 28. In fact, there are exactly four numbers below fifty that can be expressed in such a way: 28 = 22 + 23 + 24 33 = 32 + 23 + 24 49 = 52 + 23 + 24 47 = 22 + 33 + 24 How many numbers below fifty million can be expressed as the sum of a prime square, prime cube, and prime fourth power? """ __author__ = 'julenka' from primes import primesfrom2to # 4th root of 50,000,000 is 84 primes = primesfrom2to(8000) print primes count = 0 max_value = 50000000 numbers = set() for first in primes: for second in primes: for third in primes: sum_primes = first**2 + second**3 + third**4 if sum_primes < max_value: numbers.add(sum_primes) print len(numbers)
#!/usr/bin/python import primes as prms ofile=open("multiplesTo1MilTest.txt","w") ofile.write("0\n1\n") bigN=1000000 primes=prms.primesfrom2to(bigN) decomposed=[list() for i in range(bigN+1)] for i in range(2,bigN+1): cm=list() val=int(i) if i in primes: cm=[i] else: for p in primes: if i%p==0: cm.append(p) cm+=decomposed[i/p] break decomposed[val]=list(cm) ofile.write(" ".join(map(str,cm))+"\n")
Find the value of n ≤ 1,000,000 for which n/φ(n) is a maximum. FORMULA: φ(n) = n * PRODUCT[unique prime factors p of n] ( 1 - 1/p) """ from primes import primesfrom2to from collections import defaultdict MAX_VAL = 10 ** 6 # n->set(divisors) # divisors is set of unique prime factors only divisor_map = {} primes = [1] + list(primesfrom2to(MAX_VAL)) # print primes print "getting unique prime divisors..." for i in xrange(1, MAX_VAL + 1): if i % 10 ** 3 == 0: print i divisor_map[i] = set() j = 1 while j < len(primes) and primes[j] <= i: if i % primes[j] == 0: divisor_map[i].add(primes[j]) other = i / primes[j] divisor_map[i] = divisor_map[i].union(divisor_map[other]) break
result will always be prime. For example, taking 7 and 109, both 7109 and 1097 are prime. The sum of these four primes, 792, represents the lowest sum for a set of four primes with this property. Find the lowest sum for a set of five primes for which any two primes concatenate to produce another prime. """ import itertools from primes import primesfrom2to from collections import defaultdict from math import factorial import sys MAX_PRIME = 10 ** 9 N = 4 print "finding primes..." primes = set(primesfrom2to(MAX_PRIME)) candidates = primesfrom2to(10 ** 5) def test(a): for p1, p2 in itertools.permutations(a, 2): s1, s2 = str(p1), str(p2) if int(s1 + s2) not in primes: return False return True def choose(n, r): """ n choose r """ return factorial(n) / (factorial(n - r) * factorial(r)) def printline(s):
The smallest number expressible as the sum of a prime square, prime cube, and prime fourth power is 28. In fact, there are exactly four numbers below fifty that can be expressed in such a way: 28 = 22 + 23 + 24 33 = 32 + 23 + 24 49 = 52 + 23 + 24 47 = 22 + 33 + 24 How many numbers below fifty million can be expressed as the sum of a prime square, prime cube, and prime fourth power? """ __author__ = 'julenka' from primes import primesfrom2to # 4th root of 50,000,000 is 84 primes = primesfrom2to(8000) print primes count = 0 max_value = 50000000 numbers = set() for first in primes: for second in primes: for third in primes: sum_primes = first ** 2 + second ** 3 + third ** 4 if sum_primes < max_value: numbers.add(sum_primes) print len(numbers)
import time import numpy as np def numbers_on_diagonals(side_length): nums = [1] for s in range(3, side_length, 2): for i in range(4): nums.append(nums[-1] + s - 1) return nums # print(numbers_on_diagonals(7)) s = time.time() primes = primesfrom2to(1000000000) p_ind = 0 # primes = np.array(primes) print("Calculated ", len(primes), " primes in ", time.time() - s, " seconds!") def is_prime(num, next_num=None): global primes global p_ind i = p_ind while i < len(primes): if primes[i] >= num: break else: i += 1 # for i, p in enumerate(primes):
5 + 3 + 2 3 + 3 + 2 + 2 2 + 2 + 2 + 2 + 2 What is the first value which can be written as the sum of primes in over five thousand different ways? """ __author__ = 'julenka' from primes import primesfrom2to import sys import itertools if len(sys.argv) < 2: print "usage: {} prime_max_value max_primes_in_sum".format(__file__) exit(1) prime_max_value = int(sys.argv[1]) max_primes_in_sum = int(sys.argv[2]) primes = primesfrom2to(prime_max_value) upper_bound = 83 from collections import Counter prime_summations_count = Counter() for combination_length in xrange(1, max_primes_in_sum + 1): candidate_primes = [x for x in primes if 2 * combination_length - 2 + x < upper_bound] for combinations in itertools.combinations_with_replacement(candidate_primes, combination_length): prime_sum = sum(combinations) prime_summations_count[prime_sum] += 1 prime_summations_gt_5000 = filter(lambda (x, y): y > 5000, prime_summations_count.items()) print sorted(prime_summations_gt_5000)