def match(x, y):
if y > 10**16:
return False
fact_x = pp.factorize(x)
fact_y = pp.factorize(y)
exp_x = sorted([elm[1] for elm in fact_x])
exp_y = sorted([elm[1] for elm in fact_y])
return exp_x == exp_y
def getSolution(limit):
resultFactors = {x: 0 for x in xrange(1, limit + 1)}
for x in (pyprimesieve.factorize(x) for x in xrange(2, limit + 1)):
for prime, power in x:
if resultFactors[prime] < power:
resultFactors[prime] = power
return reduce(operator.mul, (x**resultFactors[x] for x in resultFactors),
1)
def divisors(n):
fact = pp.factorize(n)
divgen = []
for elm in fact:
pr, expon = elm
divgen.append([pr**i for i in xrange(expon+1)])
for nums in product(*divgen):
yield reduce(mul, nums)
def perfect_orders(n):
fac = pp.factorize(n)
chk = tuple(sorted([j for i, j in fac]))
if chk in cache:
return cache[chk]
facs = [range(j+1) for i, j in fac]
divs = product(*facs)
divs = [sum(div) for div in divs]
res = Counter(divs).most_common(1)[-1][-1]
cache[chk] = res
return res
def lcm(num):
''' Find the smallest positive number that is divisible by all the numbers
from 1 to 'num' '''
factor = defaultdict(int)
for n in range(1, num + 1):
for p, e in factorize(n):
factor[p] = max(factor[p], e)
total = 1
for p, e in factor.items():
total *= p**e
return total
def factorial_factors(end):
''' Returns dict of prime factors of factorials from 1 to 'end' '''
factors = {1: {}}
for n in range(2, end):
factors[n] = defaultdict(int)
for p, e in factors[n - 1].items():
factors[n][p] = e
for p, e in factorize(n):
factors[n][p] += e
del factors[1]
return factors
def main():
''' Brute-forces the answer by finding prime factors of test until n
adjacent numbers with n distinct primes are found '''
test = 2
count = 0
n = 4
while count < n:
count += 1
if len(factorize(test)) != n:
count = 0
test += 1
print(test - n)
def find_num_divisors(end):
''' Calculate the number of divisors for each number up to 'end' '''
num_divisors = [0 for _ in range(2, end)]
prime = set(primes(10**7))
for n in range(2, end):
divisors = 1
if n not in prime:
factors = factorize(n)
for _, e in factors:
divisors *= (e + 1)
num_divisors[n - 2] = divisors
return num_divisors
def main():
''' Driver function '''
total = 0
for n in range(5, 10001):
denom = m(n)
terminate = True
for p, _ in factorize(denom // gcd(n, denom)):
if p not in {2, 5}:
terminate = False
break
total += n if not terminate else -n
print(total)
def gazinga(n, nmax=10**9):
if n in gazinga_cache:
return gazinga_cache[n]
elif isprimepower(n):
prime, exponent = pp.factorize(n)[0]
gazinga_cache[n] = 2**(exponent-1)
return 2**(exponent-1)
else:
res = 0
for d in divisors(n):
if d < n:
res += gazinga(d, nmax=10**9)
if res > nmax:
break
gazinga_cache[n] = res
return gazinga_cache[n]
def factorization(n):
''' Return a set with all possible factorizations of 'n' '''
prev = [tuple(p for p, e in factorize(n) for _ in range(e))]
factors = len(prev[0])
total = {prev[0]}
for c in range(factors - 2):
cur = set()
for p in prev:
for i, a in enumerate(p):
for j, b in enumerate(p[i + 1:]):
cur.add(
tuple(
sorted((a * b, ) + p[:i] + p[i + 1:i + j + 1] +
p[i + j + 2:])))
prev = cur
total.update(cur)
return total
def gen_divisors(n):
''' Generator for divisors of 'n' '''
factors = factorize(n)
nfactors = len(factors)
f = [0] * nfactors
while True:
yield reduce(lambda x, y: x * y,
[factors[x][0]**f[x] for x in range(nfactors)], 1)
i = 0
while True:
f[i] += 1
if f[i] <= factors[i][1]:
break
f[i] = 0
i += 1
if i >= nfactors:
return
def partial_orders(n):
fac = pp.factorize(n)
chk = tuple(sorted([j for i, j in fac]))
if chk in cache:
return cache[chk]
fac = [[i]*j for i, j in fac]
res = [1]
while fac:
primes = [p[0] for p in fac if p!=[]]
print 'primes:', primes
print 'fac: before:', fac
fac = [p[1:] for p in fac if len(p)>1]
print 'fac: after:', fac
newres = list(product(primes, res))
newres = list(set([reduce(mul, i) for i in newres]))
res = newres
print res
cache[chk] = len(res)
return len(res)
def S(n):
''' Implementation of the S(n) function described above '''
n_sqr = n * n
total = 0
primes = primes_to(n)
primes_set = set(primes)
for i, a in enumerate(primes):
# m is an integer such that if f(x) = (x*m)**2 for any natural x, f(x)
# returns the xth perfect square divisible by a+1
# From: https://math.stackexchange.com/a/4084884/530956
m = 1
for p, e in factorize(a + 1):
m *= p**(ceil(e / 2))
m_sqr = m * m
x = a // n
val = m_sqr // (a + 1)
c = x * x * val - 1
while (c := c + val * (2 * x + 1)) < n:
x += 1
if (c in primes_set) and ((b := x * m - 1)
in primes_set) and (a < b < c):
total += a + b + c
def isprimepower(n):
facts = pp.factorize(n)
return len(facts) == 1
def factor_pairs_square(num):
''' Find the number of factor pairs of 'num**2' '''
pairs = 1
for _, e in factorize(num):
pairs *= 2 * e + 1
return (pairs + (pairs % 2)) // 2
def main():
''' Driver function '''
print(factorize(600851475143)[-1][0])
from pyprimesieve import factorize print factorize(600851475143)[-1][0]
break
i = 0
while n % p == 0:
n //= p
i += 1
if i > 0:
prime_factors.append((p, i))
if n > 1:
prime_factors.append((n, 1))
return prime_factors
class TestFactorize(unittest.TestCase):
def test_negative_1(self):
self.assertEqual(pyprimesieve.factorize(-1), [])
def test_negative_2(self):
self.assertEqual(pyprimesieve.factorize(-48485), [])
l = list(range(10**6))
random.shuffle(l)
l = l[:10**4]
for i, n in enumerate(l):
test = lambda self: self.assertTrue(sequences_equal(pyprimesieve.factorize(n), factorize(n)))
setattr(TestFactorize, 'test_' + str(i), test)
if __name__ == "__main__":
unittest.main()
def isprime(n):
fact = pp.factorize(n)
return len(fact)==1 and fact[0][1]==1
def getSolution(limit):
return max(x[0] for x in pyprimesieve.factorize(limit))
import pyprimesieve as pp
def rep_rem(k, n):
r = 0
k = 10**k
while k:
r = (10 * r + 1) % n
k -= 1
return r
def check_rems(n):
rems = set()
i = 1
while True:
rem = rep_rem(i, n)
if rem == 0:
return False
if rem in rems:
return n
else:
rems.add(rem)
i += 1
for i in xrange(2, 100):
fact = pp.factorize(i)
if len(fact)==1 and fact[0][1]==1:
if check_rems(i) == False:
print i
def test_negative_1(self):
self.assertEqual(pyprimesieve.factorize(-1), [])
def test_negative_1(self):
self.assertEqual(pyprimesieve.factorize(-1), [])
def test_negative_2(self):
self.assertEqual(pyprimesieve.factorize(-48485), [])
def div_sum(n):
''' Return sum of divisors of 'n' '''
total = 1
for p, e in factorize(n):
total *= (p**(e + 1) - 1) // (p - 1)
return total
def rad(n):
''' Find the radical of 'n' '''
total = 1
for p, _ in factorize(n):
total *= p
return total
break
i = 0
while n % p == 0:
n //= p
i += 1
if i > 0:
prime_factors.append((p, i))
if n > 1:
prime_factors.append((n, 1))
return prime_factors
class TestFactorize(unittest.TestCase):
def test_negative_1(self):
self.assertEqual(pyprimesieve.factorize(-1), [])
def test_negative_2(self):
self.assertEqual(pyprimesieve.factorize(-48485), [])
l = list(range(10**6))
random.shuffle(l)
l = l[:10**4]
for i, n in enumerate(l):
test = lambda self: self.assertTrue(
sequences_equal(pyprimesieve.factorize(n), factorize(n)))
setattr(TestFactorize, 'test_' + str(i), test)
if __name__ == "__main__":
unittest.main()
def min_fact(n):
fact = pp.factorize(n)
res = 1
for p, a in fact:
res = max(res, min_k(p, a))
return res
def test_negative_2(self):
self.assertEqual(pyprimesieve.factorize(-48485), [])
def squarefree(n):
''' Check if 'n' is squarefree '''
return not any(e > 1 for _, e in factorize(n))
def factorize(n):
"""
Factorizes the number given
"""
import pyprimesieve
return pyprimesieve.factorize(int(n))
import pyprimesieve as pp
numdivs=[0]
for i in xrange(1, 10**8+1):
num = 1
for pr, exp in pp.factorize(i):
num *= (exp + 1)
numdivs.append(num)
def M(n, k):
return max(numdivs[n:n+k])
def S(u, k):
ans = 0
for n in xrange(1, u-k+2):
ans += M(n, k)
return ans
print S(10**8, 10**5)
