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_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 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)