def generate_min_ps(max_k):
# First, we only need to consider values twice that of k
limit = 2 * max_k
# We also only need to use primes that are <= limit
prime_set = primes.generate_primes(limit)
# Now generate the set of all products using those values.
start_psr = MinPSumRecord([], 1, 0)
prods = dict()
# The results are returned through the history dictionary "prods"
generate_prods(prime_set, limit, prods, start_psr)
# So now go through the values and generate the min prod sums
min_psn = dict()
for psr in prods.values():
# The value is just the product
val = psr.product
# For the size of the set, we need to add 1s to make up the difference
# based on the difference between the product and sum
set_size = len(psr.factors) + (psr.product - psr.sum)
# Must be composed of at least two numbers
if set_size < 2 or set_size > max_k:
continue
# If we haven't seen this set size or the value is smaller, update
if set_size not in min_psn or val < min_psn[set_size]:
# print set_size, val, psr
min_psn[set_size] = val
# We have the result
return min_psn
def compute_prime_mods(xs):
# All primes less than the max value are relevant.
ps = generate_primes(max(xs))
mods = defaultdict(set)
for p in ps:
# Compute all the xs mod p.
xsp = set(x % p for x in xs)
# A value can be added if does not become 0 mod p for some x.
for i in xrange(p):
if (p - i * i) % p not in xsp:
mods[p].add(i)
return mods
def solve_p187(limit, verbose=True):
if verbose:
print "Generating primes..."
primes = list(generate_primes(limit / 2))
if verbose:
print "Computing value..."
hi = len(primes)
result = 0
i = 0
while hi > 0 and i < len(primes):
hi = bisect_right(primes, limit / primes[i], lo=i, hi=hi)
result += hi - i
i += 1
return result
def gen_composite(limit):
result = dict()
result[1] = defaultdict(int)
ps = list(generate_primes(limit / 2))
def rec_composite(n, ps, fact):
p = ps[0]
curr = n * p
i = 1
while curr <= limit:
fact[curr] = fact[n].copy()
fact[curr][p] = i
if len(ps) > 1:
for j in xrange(len(ps) - 1):
if curr * ps[j + 1] > limit:
break
rec_composite(curr, ps[j + 1:], fact)
i += 1
curr *= p
for i in xrange(len(ps)):
rec_composite(1, ps[i:], result)
return result
def solve_p243(plimit, ratio):
# First compute the primorial which has resilience less than the ratio.
ps = list(generate_primes(plimit))
totient = 1
prod = 2
index = 1
last_p = 2
while index < len(ps) and totient/(prod-1.0) >= ratio:
totient *= ps[index] - 1
prod *= ps[index]
last_p = ps[index]
index += 1
# Now compare the primorial value against multiples of the previous
# primorial which are also less than the ratio.
best = prod
start_totient = totient/(last_p - 1)
start_prod = prod/(last_p)
for i in xrange(2, last_p):
mul_fact = factor_int_dict(i)
new_totient = reduce(lambda a, p: a * p**mul_fact[p], mul_fact, start_totient)
new_prod = start_prod * i
if new_totient/(new_prod - 1.0) < ratio and new_prod < best:
best = new_prod
return best
def solve_p133(limit, test_limit=None):
result = 0
for p in generate_primes(limit):
if not test_repunit_factor(p, test_limit):
result += p
return result
def solve_p110(target, prime_limit, exp_limit):
ps = list(generate_primes(prime_limit))
best_fact = find_min_target(target, ps, dict(), exp_limit)
return prod_fact(best_fact)