def main():
# We should not count N itself per problem requirement, so might as
# well subtract 1 since otherwise all calculations only involve N-1.
n = N - 1
primes = primesieve.primes(math.sqrt(n))
squares = [p * p for p in primes]
n_squares = len(squares)
q = collections.deque()
# (next_index, current_length, current_product)
#
# next_index is the index of the next acceptable square factor,
# current_length is the current number of square factors already in,
# current_product is the product of all current square factors.
q.append((0, 0, 1))
count = 0
while q:
next_index, current_length, current_product = q.popleft()
quotient = n // current_product
# Inclusion-exclusion principle
count += pow(-1, current_length) * quotient
for i in range(next_index, n_squares):
s = squares[i]
if s > quotient:
break
q.append((i + 1, current_length + 1, current_product * s))
print(count)
def method1(n):
primes = primesieve.primes(n)
primes_set = set(primes)
n_primes = len(primes)
q = collections.deque()
q.append((0, 0, 1))
# aggregate_count = 0
total = 0
while q:
min_index, psum, pprod = q.popleft()
rsum = n - psum
if rsum in primes_set:
# aggregate_count += 1
total = (total + rsum * pprod) % MODULUS
half_rsum = rsum // 2
i = min_index
while i < n_primes and (p := primes[i]) <= half_rsum:
new_psum = psum
new_pprod = pprod
for count in range(1, rsum // p - 1):
new_psum += p
new_pprod = (new_pprod * p) % MODULUS
q.append((i + 1, new_psum, new_pprod))
if rsum % p == 0:
# rsum = (rsum // p - 2) * p + 2p, with 2p remaining.
# aggregate_count += 1
total = (total + new_pprod * p * p) % MODULUS
else:
# rsum = (rsum // p - 2) * p + r, where p < r < 2p.
new_psum += p
new_pprod = (new_pprod * p) % MODULUS
q.append((i + 1, new_psum, new_pprod))
i += 1
def part2(program):
b = 105700
c = 122700
step = 17
primes = primesieve.primes(b, c)
comps = [k for k in range(b, c + 1, step) if k not in primes]
return len(comps)
def main():
primes = primesieve.primes(3, LIMIT)
single_factor_combos = []
for p in reversed(primes):
combos = find_prime_factor_combos(p)
if combos:
single_factor_combos.insert(0, (p, [set()] + combos))
fat_combos = find_fat_combos(single_factor_combos)
find_result_combos(fat_combos)
def count_as_sums_of_primes(n, less_than):
if (n, less_than) in count_mem:
return count_mem[(n, less_than)]
output = 0
for m in primes(min(n, less_than)):
output += count_as_sums_of_primes(n - m, m)
if n == 0:
output += 1
count_mem[(n, less_than)] = output
return output
def main():
max_length = int(sys.argv[1]) if len(sys.argv) > 1 else 10000
validate(max_length)
start = int(rank * (max_length / size))
end = int(rank * (max_length / size) + (max_length / size))
primes = np.array(primesieve.primes(start, end), dtype=np.long)
gather_and_print(primes)
def main():
primes = primesieve.primes(N)
s = 1
for p in primes:
vp = 0
n = N
while n >= p:
n //= p
vp += n
s *= 1 + pow(p, 2 * vp, MODULUS)
s %= MODULUS
print(s)
def gen_prime(min, max):
"""
Eratosthenes sieve http://code.activestate.com/recipes/117119/
https://github.com/hickford/primesieve-python
"""
prime_list = primesieve.primes(min, max)
while (not prime_list):
min = max
max += 100
prime_list = generate_primes(min, max)
n = randint(0, len(prime_list) - 1)
return prime_list[n]
def minsqrsum(n, maxtry=8):
"""Return a list n+1 long; array[n] is the least number of squares of primes or 1
to sum to n, or 0 if more than maxtry are required."""
last = floor(sqrt(n))
facs = [0, 1] + list(primesieve.primes(last))
numsum = [0] * (n + 1)
for nums in combinations_with_replacement(facs, maxtry):
val = sum(x**2 for x in nums)
if val <= n:
notzero = sum(1 for x in nums if x)
if not numsum[val] or notzero < numsum[val]:
numsum[val] = notzero
return numsum
def calculate_pseudofortunates(N):
primes = primesieve.primes(int(pow(N, 0.5)))
n_primes = len(primes)
admissibles = []
q = collections.deque()
q.append((1, 0))
while q:
n, i = q.popleft()
if i < n_primes:
p = primes[i]
i += 1
while (n := n * p) < N:
admissibles.append(n)
q.append((n, i))
def main():
primes = primesieve.primes(999983)
total = 0
for k in range(len(primes) - 1):
p = primes[k]
q = primes[k + 1]
pq = p * q
for n in range(p * (p + 1), q * q, p):
if n != pq:
total += n
for n in range(q * (q - 1), p * p, -q):
if n != pq:
total += n
print(total)
def main():
limit = 1000
primes = primesieve.primes(limit // 2)
n = len(primes)
small_multipliers = []
for i in range(n - 1):
p = primes[i]
if p**3 <= limit:
small_multipliers.append(p**3)
for j in range(i + 1, n):
q = primes[j]
if p * q <= limit:
small_multipliers.append(p * q)
small_multipliers.sort()
print(len(small_multipliers), small_multipliers)
def prime_divisors(n: int):
"""Returns the prime divisors of a number, except 1.
EX: prime_divisors(12) -> [2,3]
prime_divisors(17) -> [17]
- n : The number to find the divisors of.
prime_divisors(n: int) -> list"""
divisors_ = divisors(n)[1:]
primes_ = ps.primes(2,n+1) # Can be optimized by setting second limit to sqrt(n)
# I need an isprime() function first so that n can be tested
# for primality in a more efficient way
pdivisors_ = [d for d in divisors_ if d in primes_] # Might be faster than searching for
# p in divisors_
return pdivisors_
def count(n):
primes = primesieve.primes(n)
sum_counts = collections.defaultdict(int)
sum_counts[0] = 1
for i, p in enumerate(primes):
if (i + 1) % 100 == 0:
print(f"progress: {i+1}-th prime")
prev_sums = sorted(sum_counts.keys(), reverse=True)
for prev_sum in prev_sums:
sum_counts[prev_sum + p] = (sum_counts[prev_sum + p] +
sum_counts[prev_sum]) % MODULUS
total_count = 0
for sum_, count in sum_counts.items():
if miller_rabin.miller_rabin(sum_):
total_count = (total_count + count) % MODULUS
return total_count
def method3_non_recursive(n):
primes = primesieve.primes(n)
SS = [[1]]
S = [1]
for k in range(1, n + 1):
if k % 5_000 == 0:
print(f"progress: {k}")
SSk = []
pi = sympy.primepi(k)
for i in range(pi):
p = primes[i]
SSkmp = SS[k - p]
SSk.append(((SSk[i - 1] if i > 0 else 0) + p *
(SSkmp[i] if i < len(SSkmp) else
(SSkmp[-1] if SSkmp else 0))) % MODULUS)
SS.append(SSk)
S.append(SSk[pi - 1] if pi >= 1 else 0)
def method3(n):
primes = primesieve.primes(n)
# S[k, i] is the sum of numbers whose prime factor sum is k and
# whose prime factors are among the primes[0], primes[1], ...,
# primes[i].
@functools.lru_cache(maxsize=None)
def S(k, i):
if k == 0:
return 1
if i < 0:
return 0
p = primes[i]
if k < p:
return S(k, i - 1)
else:
return (S(k, i - 1) + p * S(k - p, i)) % MODULUS
return [S(k, sympy.primepi(k) - 1) for k in range(n + 1)]
def random_hdf5_params():
factors = np.concatenate((primesieve.primes(28), [2, 2])).astype(int)
n_dims = np.random.randint(2, 8)
axes = np.ones(n_dims, dtype=int)
for f in factors:
axis = np.random.randint(0, n_dims)
axes[axis] *= f
sig_dims = np.random.randint(1, n_dims)
chunking = np.zeros(n_dims, dtype=int)
while np.prod(chunking) < 4096 or np.prod(chunking) > 128 * 1024 * 1024:
for d in range(n_dims):
# Distribution with heavy skew towards small chunk sizes
chunking[d] = int(np.exp(np.random.uniform(0, np.log(axes[d]))))
return (factors, axes, chunking, sig_dims)
def method2(n):
primes = primesieve.primes(n)
n_primes = len(primes)
S = [1]
for k in range(1, n + 1):
s = 0
q = collections.deque()
q.append((0, k, 1, -1))
while q:
min_index, rsum, pprod, sign = q.popleft()
if min_index > 0:
s = (s + sign * pprod * S[rsum]) % MODULUS
for i in range(min_index, n_primes):
p = primes[i]
if p > rsum:
break
q.append((i + 1, rsum - p, (pprod * p) % MODULUS, -sign))
S.append(s)
return S
def main():
limit = 1_000_000_000_000
primes = primesieve.primes(pow(limit, 1 / 2))
squbes = set()
for q in primes:
q3 = pow(q, 3)
if q3 * 4 > limit:
break
for p in primes:
if p == q:
continue
n = p * p * q3
if n > limit:
break
s = str(n)
if "200" not in s:
continue
squbes.add(n)
length = len(s)
failed = False
for i in range(length):
ss = [ch for ch in s]
d = s[i]
if i == 0:
replacements = set("123456789")
elif i == length - 1:
replacements = set("1379")
else:
replacements = set("0123456789")
replacements.discard(d)
for dd in replacements:
ss[i] = dd
nn = int("".join(ss))
if miller_rabin.miller_rabin(nn):
failed = True
break
if failed:
break
if not failed:
squbes.add(n)
for i, n in enumerate(sorted(squbes)):
print(i + 1, n)
def search_row(n):
# (n+k)-th row: (n+k-1)(n+k)/2 + 1 to (n+k+1)(n+k)/2
# (n-2)-th to (n+2)-th row: (n-2)(n-3)/2 + 1 to (n+2)(n+3)/2
primes = primesieve.primes((n - 2) * (n - 3) // 2 + 1,
(n + 2) * (n + 3) // 2)
rows = {
row_num: [False for _ in range(row_num)]
for row_num in range(n - 2, n + 3)
}
row_starts = {}
row_start = (n - 2) * (n - 3) // 2 + 1
row_num = n - 2
row_starts[row_num] = row_start
nth_row_prime_coords = []
for p in primes:
if p >= row_start + row_num:
row_start = row_start + row_num
row_num += 1
row_starts[row_num] = row_start
rows[row_num][p - row_start] = True
if row_num == n:
nth_row_prime_coords.append(p - row_start)
elligible_primes = []
x = n
for y in nth_row_prime_coords:
p = row_starts[x] + y
for (dx1, dy1), (dx2, dy2) in possible_extensions:
x1 = x + dx1
y1 = y + dy1
x2 = x + dx2
y2 = y + dy2
if not (0 <= y1 < x1 and 0 <= y2 < x2):
continue
if rows[x1][y1] and rows[x2][y2]:
elligible_primes.append(p)
break
return elligible_primes
def decimal_terminates(numerator: int, denominator: int):
"""Returns True if a fraction terminates.
decimal_terminates(numerator: int, denominator: int) -> bool"""
## Concept: All simplified fractions whose denominators have any prime factors other than
## 1, 2, or 5 are non-terminating in base 10.
# Auto-simplify the fraction unless it is very large
n = Fraction(numerator, denominator).denominator
# Check for prime factors other than 1, 2, or 5 in the denominator
if n <= 2:
primes = [3, 7]
if n > 2:
primes = [3, 7] + [p for p in ps.primes(10, n + 1)]
# If sqrt limit is used, the function excludes the case that n is prime
# If any of the primes evenly divides n, return False (denom isn't terminating)
if any([not n % p for p in primes]):
return False
return True # Return true by default
def main():
global primes, factorizations, appearances
prime_bound = int(math.sqrt(bound))
primes = primesieve.primes(prime_bound)
prime_index = {p: i for i, p in enumerate(primes)}
appearances = [[] for _ in primes]
for i, p in enumerate(primes):
factorization = []
for q, e in sorted(sympy.ntheory.factorint(p - 1).items(),
reverse=True):
factorization.append((prime_index[q], q, e))
appearances[prime_index[q]].append((i, p, e))
factorizations.append(factorization)
for i, p in enumerate(primes):
orphans = {j: e % 3 for j, _, e in factorizations[i] if e % 3 != 0}
n = p * p
while n < bound:
search(n, i, orphans)
n *= p * p * p
global results
count = len(results)
sorted_results = sorted(results)
s = collections.deque()
s.append((1, -1))
while s:
n, i = s.pop()
if n != 1:
results.add(n)
for j in range(i + 1, count):
prod = n * sorted_results[j]
if prod >= bound:
break
if math.gcd(n, sorted_results[j]) == 1:
s.append((prod, j))
# print(sorted(results))
print(sum(results))
def main():
limit = int(math.sqrt(N))
primes = primesieve.primes(limit)
is_composite = [True] * (limit + 1)
is_composite[1] = False
for p in primes:
is_composite[p] = False
is_power = [False] * (limit + 1)
total = 0
for a in range(2, limit + 1):
if is_power[a]:
continue
a_is_composite = is_composite[a]
b = 2
n = a * a
while n <= N:
if a_is_composite or is_composite[b]:
total += n
if n <= limit:
is_power[n] = True
b += 1
n *= a
print(total - 16)
def main():
total = 0
primes = set(primesieve.primes(BOUND))
for g in range(2, BOUND // 4 + 1):
root = int(math.sqrt(g))
if root * root == g:
if root % 2 == 0 and root == int(math.sqrt(root))**2:
print(f"progress: {g}")
continue
for c0 in range(2, int(math.sqrt((BOUND - 1) / g)) + 1):
c = g * c0 * c0 - 1
if not c in primes:
continue
for a0 in range(1, c0):
if math.gcd(a0, c0) != 1:
continue
a = g * a0 * a0 - 1
if not a in primes:
continue
b = g * a0 * c0 - 1
if not b in primes:
continue
total += a + b + c
print(total)
# the OG project is looking at ranges of .1M = 100,000
SIZE = 100000
rem_threshold = 2 * (SIZE // 100)
extra_threshold = 40
# [0, SIZE], [SIZE, 2*SIZE], [2*SIZE, 3*SIZE]
# don't have to work about overlap with ] and [ because SIZE is composite
counts = [[0, 0] for _ in range(0, STOP, SIZE)]
# I want this to contain all primes without factors
# Ideally we'd do something in two passes, or one combined pass
# to avoid adding then removing all primes but that's hard to write.
unfactored = [set() for _ in range(0, STOP, SIZE)]
for prime in primesieve.primes(0, STOP):
interval = prime // SIZE
counts[interval][0] += 1
unfactored[interval].add(prime)
##### Handle Numbers with factors (and mersenne primes) #####
with open(factor_fn) as f:
last_m = 0
for line in f:
raw = line.split(",")
m, k = int(raw[0]), int(raw[1])
if m > STOP:
break
assert pow(2, m, 2 * m * k + 1) == 1
def is_powerful(n):
for p in primesieve.primes(n):
if n%p==0 and n%int(math.pow(p,2))!=0:
return False
return True
from primesieve import primes
p = primes(1000000)
index = 0
ans = 1
while ans * p[index] <= 1000000:
ans = ans * p[index]
index = index + 1
print(ans)
def test_converter_3():
primes_test = primes(990000000, 999999999)
for n in primes_test:
assert to_number(num2words(n, lang="es")) == n
15 = 3 × 5
The first three consecutive numbers to have three distinct prime factors are:
644 = 2² × 7 × 23
645 = 3 × 5 × 43
646 = 2 × 17 × 19.
Find the first four consecutive integers to have four distinct prime factors each. What is the first of these numbers?
'''
import primesieve
limit = 100000
primes = primesieve.primes(limit)
def get_distinct_prime_factors(n, primes):
result = 1
for p in primes:
if p * p > n:
break
f = False
while n % p == 0:
f = True
n = n // p
if f:
result += 1
return result
#! python3
# $ pip3 install primesieve
# Answer: 17427258 in 0m1.190s unix time (time python3 pe187.py)
import primesieve
n = 10**8
sqrt_n = 10**4
primes = primesieve.primes(n/2)
end = len(primes) - 1
start = 0
result = 0
for p in primes:
if sqrt_n < p:
break
while n < primes[end] * p:
end -= 1
result += end - start + 1
start += 1
print(result)
def test_prime_given(self):
self.cases(function=lambda n: primes_of_n(n, ls_prime=primes(100)))
number = [i for i in str(number)]
l = len(number)
low = l - 1
while low > 0:
if number[low] > number[low - 1]:
for high in reversed(range(low, l)):
if number[high] > number[low - 1]:
number[high], number[low - 1] = number[low -
1], number[high]
number[low:] = number[low:][::-1]
return int(''.join(number))
low -= 1
return 0
prime_numbers = primes(1000, 9999)
visited = set()
selected_primes = {}
for p in prime_numbers:
if p in visited:
continue
c = [p]
visited.add(p)
n = p
while True:
n = find_next_permutation(n)
if n < 1000:
break
if n in prime_numbers:
c.append(n)
