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)
assert (euler.descendingFactorial(5, -2) == 1 / 42)
assert (euler.descendingFactorial(5, -3) == 1 / 336)
assert (euler.ascendingFactorial(5, -2) == 1 / 12)
assert (euler.ascendingFactorial(5, -3) == 1 / 24)
assert (euler.factors(20, []) == [1, 2, 4, 5, 10, 20])
assert (euler.appendDigits(37465, []) == [3, 4, 5, 6, 7])
assert (euler.appendDigitsUnsorted(37465, []) == [3, 7, 4, 6, 5])
primes = euler.readPrimes()
assert (primes[0:20] == [
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71
])
#!/usr/bin/python
from euler import readPrimes
PRIMES = readPrimes()
PRIMES.reverse()
ways = {}
def countWays(money, coinIndex, coins):
while money < coins[coinIndex] and coinIndex < len(coins) - 1:
coinIndex += 1
if money == 0:
return 1
if coinIndex == len(coins) - 1:
if money % coins[coinIndex] == 0:
return 1
else:
return 0
p = (money, coinIndex)
if p in ways:
return ways[p]
else:
number = 0
coin = coins[coinIndex]
maxNumber = money // coin
way = 0
while number <= maxNumber:
way += countWays(money - number * coin, coinIndex + 1, coins)
number += 1
#!/usr/bin/python
from euler import readPrimes, primeFactors, primePowerFactorization
import math
UPPER = 10**7
LIMIT = UPPER
PRIMES = readPrimes( LIMIT )
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
assert( totient( 1, PRIMES ) == 1 )
assert( totient( 9, PRIMES ) == 6 )
assert( totient( 87109, PRIMES ) == 79180 )
def ascending( s ):
ss = list( s )
ss.sort()
return ''.join( ss )
assert( ascending( '56623104' ) == '01234566')
minimum = math.inf
if ascending(str(n)) == ascending(str(totient)):
p = n / (n - totient)
if primeMin < p:
primeMin = p
nPerm = n
n *= prime
totient *= prime
n2totient0.update(n2totient)
return n2totient0, upper, primeMin, nPerm
PRIME_MIN = 1000.0
primeMin = PRIME_MIN
UPPER = 10**7 # UPPER = 10 # UPPER = 10**5 #
PRIMES = readPrimes(UPPER / int(primeMin))
PRIMES.reverse()
n2totient0 = dict({1: 1}) # totientRatio = phi(n) / n
nPerm = 0
start = time.time()
i = 0
while i < len(PRIMES) and primeMin <= PRIMES[i]:
n2totient0, upper, primeMin, nPerm = addPrime(PRIMES[i], n2totient0, UPPER,
primeMin, nPerm)
i += 1
end = time.time()
#!/usr/bin/python
from collections import Counter
from itertools import combinations, product
from euler import readPrimes, isPrime
from copy import deepcopy
primes = readPrimes() # complete set of primes up to 15485863 digits
primea = set(primes)
DIGIT_BIG = 7
BASE = 10
DIGIT_S = range(0, BASE)
# Does the list of digits match in the positions indexed by c?
def primesWithDigitCount(d):
return [str(p_i) for p_i in primes if BASE**(d - 1) <= p_i < BASE**d]
def toDigit2Count(prime_c):
return Counter(list(prime_c))
c0 = Counter({'6': 2, '8': 2, '4': 1, '5': 1, '2': 1})
assert (toDigit2Count('4656882') == c0)
def primeWithRepeat_is(numberOfDigits_i, digit_i):
digitOther_is = list(DIGIT_S)
digitOther_is.remove(digit_i)
#!/usr/bin/python
from euler import readPrimes
from bisect import insort
import time
UPPER = 10**6 # UPPER = 8 #
PRIMES = readPrimes(UPPER)
# Constructs table of non-0 mobius function values.
# Time-complexity is O( P * A * (log A)**2 )
# P = #{ primes <= upper }, A = #{ stored Mobius arguments }
def n2mobius(upper, primes):
n2mobius = dict({1: 1})
keys = [1]
for p in primes:
if upper < p:
break
keys0 = []
for n in keys:
if upper < p * n:
break
n2mobius[p * n] = -n2mobius[n]
keys0.append(p * n)
for key0 in keys0:
insort(keys, key0)
return n2mobius
def mobiusFctAll(n, mobiusFct):
#!/usr/bin/python
from euler import readPrimes
from euler import isPrime
UPPER = 100
def appendDiagonal( ns ):
delta = ns[ -1 ] - ns[ -2 ]
delta += 8
ns.append( ns[ -1 ] + delta )
PRIMES = readPrimes() # complete set of primes up to MAX_PRIME_DIGITCOUNT digits
MAX_PRIME = max( PRIMES )
assert( MAX_PRIME == 15485863 )
PRIME_SET = set( PRIMES )
MAX_TEST = MAX_PRIME * MAX_PRIME
def isTestedPrime( n ):
if n <= MAX_PRIME:
return n in PRIME_SET
elif n <= MAX_TEST:
return isPrime( n, PRIMES )
else:
raise Exception( 'n is too large to test.' )
diagonals = [ [ 3, 13, 31 ], [ 5, 17, 37 ], [ 7, 21, 43 ] ]
numerator = 8
denominator = 13
ratio = numerator / denominator
#!/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 )
#!/usr/bin/python
from euler import readPrimes
primes = readPrimes(10**6)
pr0 = 1
for p in primes:
pr = p * pr0
if pr > 10**6:
break
pr0 = pr
print(pr0)
#!/usr/bin/python
from euler import isPrime
from euler import readPrimes
#PRIME_LIMIT = 10**6
#PRIMES = readPrimes( PRIME_LIMIT ) # list of primes up to PRIME_LIMIT
PRIMES = readPrimes() # list of 1st million primes
PRIMECS = list( map( str, PRIMES ) ) # list PRIMES as strings
PRIMECA = set( PRIMECS ) # set of PRIMECS
assert( PRIMECS[ 0 ] == '2' )
def isPrimeString( s ):
if s in PRIMECA:
return True
n = int( s )
if PRIMES[ -1 ] * PRIMES[ -1 ] < n:
raise Exception( 'isPrimeString: PRIMES[ -1 ] * PRIMES[ -1 ] < n' )
else:
return isPrime( n, PRIMES )
def isConcatenable( p0, p1 ):
return isPrimeString( p0 + p1 ) and isPrimeString( p1 + p0 )
assert( isConcatenable( '3', '7' ) )
assert( isConcatenable( '109', '673' ) )
assert( not isConcatenable( '2', '37' ) )
def concatenableTuple( SIZE ):
# Returns the first set with size size of concatenable PRIMECS not exceeding maximum.
