def totient( n, primes ):
pFs = primeFactors( n, primes )
ppFm = primePowerFactorization( pFs )
ppFmKeys = ppFm.keys()
totient = n
for primeFactor in ppFmKeys:
totient = totient - totient / primeFactor
return totient
def sumFactors(n):
if isPrime(n, primes):
return 1
ps = primeFactors(n, primes)
pPowers = primePowerFactorization(ps)
sum = 1
for p in pPowers.keys():
sum *= (p**(pPowers[p] + 1) - 1) // (p - 1)
return sum - n
def solve(limit):
best = None
i = 94744
while 1:
i += 1
r = resiliance_frac(i)
if r == 0:
continue
if not best or r <= best:
best = r
print i, best, float(best), euler.primeFactors(i)
if r < limit:
break
def ka(n):
factor2powers = list()
factor2power = primePowerFactorization(primeFactors(n, PRIMES))
factor2powers.append(factor2power)
#print( factor2powers )
ka = set()
ka.add(toK(factor2power))
j = reduce(add, [factor2power[factor]
for factor in factor2power.keys()]) # # of factors in n
while j > 0:
factor2powers0 = deepcopy(factor2powers)
k2factor2powers = dict({})
for factor2power0 in factor2powers0:
for factors in combinations_with_replacement(
factor2power0.keys(), 2):
if factors[0] == factors[1] and factor2power0[factors[0]] == 1:
continue
else:
factor2power = deepcopy(factor2power0)
factor = factors[0] * factors[1]
for i in [0, 1]:
factor2power[factors[i]] -= 1
if factor2power[factors[i]] == 0:
del factor2power[factors[i]]
if factor in factor2power.keys():
factor2power[factor] += 1
else:
factor2power[factor] = 1
k = toK(factor2power)
if k in k2factor2powers:
k2factor2powers[k].append(factor2power)
else:
k2factor2powers[k] = [factor2power]
factor2powers = list()
for k in k2factor2powers.keys():
ka.add(k)
factor2powers.extend(uniqueFactor2Powers(k2factor2powers[k]))
#print( factor2powers )
j -= 1
return ka
#!/usr/bin/python
from euler import appendToPrimes, primeFactors, primePowerFactorization
PRIMES = []
UPPER = 10**6
appendToPrimes(UPPER, PRIMES)
m = 2 # current test
foursome = 0
while foursome != m:
foursome = m
for j in range(m, m + 4):
dict = primePowerFactorization(primeFactors(j, PRIMES))
if len(dict.keys()) != 4:
m = j + 1
break
print(foursome)
import euler
#print euler.ncr(1,0),euler.ncr(1,1)
#print euler.ncr(2,0),euler.ncr(2,1)
def pascal(rows):
return [euler.ncr(rows, i) for i in range(rows + 1)]
def pascalUnique(nrows):
lst = []
for i in range(nrows):
lst += pascal(i)
lst = set(lst)
lst = list(lst)
return lst
lst = pascalUnique(50)
lst.sort()
for i, item in enumerate(lst):
print i, len(lst), item, euler.primeFactors(item)
def rad(n):
return euler.product(euler.primeFactors(n))
n = 20
primes0 = [2, 3, 5, 7, 11, 13, 17, 19]
primes = []
euler.appendToPrimes(n, primes)
assert primes == primes0
n = 30
euler.appendToPrimes(n, primes)
primes0 += [23, 29]
assert primes == primes0
primeFactors0 = [2, 5, 23]
primeFactors = euler.primeFactors(230, primes)
assert primeFactors == primeFactors0
primeFactors0 = [2, 2, 3, 3]
primeFactors = euler.primeFactors(36, primes)
assert primeFactors == primeFactors0
primePowerFactorization0 = {2: 2, 3: 2}
primePowerFactorization = euler.primePowerFactorization(primeFactors)
assert primePowerFactorization0 == primePowerFactorization
assert (euler.descendingFactorial(5, 2) == 20)
assert (euler.descendingFactorial(5, 3) == 60)
assert (euler.ascendingFactorial(5, 2) == 30)
assert (euler.ascendingFactorial(5, 3) == 210)
#!/usr/bin/python
from euler import readPrimes, primeFactors, primePowerFactorization
from operator import mul
from functools import reduce
UPPER = 1000
primes = readPrimes( UPPER )
d0 = 1
for n in range( 2, UPPER ):
pfs = primeFactors(n, primes)
p2power = primePowerFactorization(pfs)
values = list( p2power.values() )
if len( values ) == 1:
sigma0 = 1 + values[ 0 ]
else:
sigma0 = reduce( mul, [ (1 + value ) for value in values ] )
if d0 < sigma0:
d0 = sigma0
print( n )
import euler
# print euler.ncr(1,0),euler.ncr(1,1)
# print euler.ncr(2,0),euler.ncr(2,1)
def pascal(rows):
return [euler.ncr(rows, i) for i in range(rows + 1)]
def pascalUnique(nrows):
lst = []
for i in range(nrows):
lst += pascal(i)
lst = set(lst)
lst = list(lst)
return lst
lst = pascalUnique(50)
lst.sort()
for i, item in enumerate(lst):
print i, len(lst), item, euler.primeFactors(item)
def oldhamming(n, m):
return max(euler.primeFactors(n)) <= m
def oldhamming( n, m ):
return max(euler.primeFactors(n)) <= m
