def main(): primes.init(10**6) sums = [0]*(10**6+1) for x in range(1,10**6): primes.factor(x) print x print x
def func(num): fracs = num - 1 for x in range(2, num): for y in range(x + 1, num + 1): if y % x: if not set(factor(y)) & set(factor(x)): fracs += 1 return fracs
def collapseNumIntoFactorPowers(number): factors = primes.factor(number) powerDict = dict() for f in factors: try: powerDict[f] += 1 except KeyError: powerDict[f] = 1 return tuple(sorted(powerDict.values()))[::-1]
def find_consecutive_n_factor_integers(goal): n = 1 in_a_row = 0 while in_a_row < goal: factors = factor(n) if len(factors) == goal: in_a_row += 1 else: in_a_row = 0 n += 1 return n - goal
def smallest_k(n,min=0): if gcd(n,10) != 1: return None if gcd(n-9,n) != 1: return None # return handle_zero_divisors(n) factors = primes.all_factors(primes.factor(primes.euler_phi(n))) if factors[-1] < min: return None for factor in factors: factor = int(factor) if pow(10,factor,n) == 1: if factor < min: return None return factor
def handle_zero_divisors(n): print "Zero divisors", factors = primes.all_factors(primes.factor(primes.euler_phi(n))) possibilities = PriorityQueue() for factor in factors: factor = int(factor) if pow(10,factor,n) == 1: possibilities.put((factor,factor,1)) if possibilities.empty(): return None while True: #should eventually terminate _,factor,multiple = possibilities.get() if pow(100,factor,n) == 1: print n,factor*multiple return factor*multiple possibilities.put((factor*(multiple*1),factor,multiple+1))
def gendivs(divs, n): # 3*n^2 c = factor(divs, n) c = c+c c[3] += 1 f = list(c.items()) c, go, m = [0]*len(f), True, 1 while go: yield m go = False for i,(fact,num) in enumerate(f): if c[i] < num: c[i] += 1 m *= fact go = True break m //= fact**num c[i] = 0
def recurse(n,num,denom, result=[]): if num * 2 == denom: print int(denom**.5), factor(int(denom**.5)), n-1 print '\t\t', result used.update(set(result)) return 1 elif num*2 > denom or n > MAX_SIZE or num*1./denom + partial_sums[n] < .4999999: return 0 while n in numToExclude: n+=1 if n > MAX_SIZE: return 0 if denom % n**2 == 0: b = recurse(n+1, num+denom/n**2, denom, result + [n]) else: b = recurse(n+1, num*n**2+denom, denom*n**2, result + [n]) a = recurse(n+1,num,denom, result) return a+b
size = 10**6 if len(sys.argv) > 1: size = int(sys.argv[1]) lst = bitarray('0' * (size+1)) count = 0 for i in xrange(2,size+1): if i%10240 == 0: print i if lst[i] == 0: if not mr(2*i*i - 1): if i < size//500: a = set(factor(2*i**2-1)[:-1]) for j in a: for k in xrange((-i)%j+j,size+1,j): lst[k] = 1 for k in xrange(i,size+1,j): lst[k] = 1 count +=1 else: count +=1 print size -1 - count print "Time Taken:", time.time() - start """ ~/Desktop/python_projects/proj_euler $python prob216.py 1000000
import time from primes import gcd, m_r, factor START = time.time() SIZE = 100 sumz = 0 for i in xrange(1,SIZE+1): factors = factor(i+1) + factor(i**2 - i + 1) biggestFactor = sorted(factors)[-1] print i, biggestFactor sumz += biggestFactor - 1 print "Answer:", sumz print "Time Taken:", time.time() - START """ Congratulations, the answer you gave to problem 343 is correct. You are the 930th person to have solved this problem. Answer: 269533451410884183 Time Taken: 1570.37111306 Turns out that the 1/k fraction transforms into the (largest prime factor of k+1) - 1, so 1/6 -> 6, and 9 -> largestFactor(9+1) = 5 -> 4 """
start = time.time() from math import * fa = factorial from primes import factor size = 20 def log10(n): return log(n) / log(10) total = sum([log(n) for n in range(2, size + 1)]) total = int(1000 * total + .5) / 1000. vals = [int(1000 * log(n) + .5) / 1000. for n in factor(fa(size))[:-1]] print total print vals, sum(vals) goal_val = total / 3. prev_seen = {} def helper(n, pos): if (n, pos) in prev_seen: return prev_seen[(n, pos)] #base case if pos >= len(vals) or n >= goal_val: return n
for m in xrange(2,TEST_SIZE): for n in xrange(1,m): if 2 * m * n > MAX_TRI_SIZE: break if gcd(m,n) != 1: continue for k in xrange(1,TEST_MULT_SIZE): if (m**2 - n**2) * k > MAX_TRI_SIZE or \ 2 * m * n * k > MAX_TRI_SIZE: break tripletSum = 2*m*k*(m+n) insertOrIncrement(2*m*n*k) for key in catDict.keys(): if catDict[key] >= MIN_LIM: print key, catDict[key], factor(key) print max(catDict.values()) print "Time Taken:", time.time() - START """ Suppose that the number b is even. Why does that guarantee a solution for: b = k_2 x (m_2^2 - n_2^2) if a solution for: b = 2mnk m_1 > n_1 exists? 2mnk: m = (m_2^2-n_2^2) n = 1 k = k_2/2
#!/usr/bin/env python import primes import sys #The numerical argument which we should be factoring should #is the first command line argument: inputNum = None; try: rawArgument = sys.argv[1]; inputNum = int(rawArgument); except (IndexError, ValueError): print "You must provide an integer argument for this script to factorize!"; sys.exit(1); if inputNum is None: print "There was an error parsing the input. Exiting..."; sys.exit(1); if inputNum < 2: print "Enter a integer argument that is larger than 2"; sys.exit(1); listOfFactors = primes.factor(inputNum); print listOfFactors;
#!/usr/bin/env python import primes import sys #The numerical argument which we should be factoring should #is the first command line argument: inputNum = None try: rawArgument = sys.argv[1] inputNum = int(rawArgument) except (IndexError, ValueError): print "You must provide an integer argument for this script to factorize!" sys.exit(1) if inputNum is None: print "There was an error parsing the input. Exiting..." sys.exit(1) if inputNum < 2: print "Enter a integer argument that is larger than 2" sys.exit(1) listOfFactors = primes.factor(inputNum) print listOfFactors
import time from primes import divisors, factor, pfactor_gen START = time.time() SIZE = 10**6 factors = pfactor_gen(SIZE) for i in xrange(2, SIZE, 2): if sum(divisors(i)) % i == i / 2: print i, factor(i) print "Time Taken:", time.time() - START """ 2: 1,3,7,15,31,65,129 3: 1,4,10,40,121,364 5: 1,6,31,156,781,3906 p(2) = 3/2 -> 1 1/2 p(24) = (13 * 4)/8 = 6 1/2 p(4320) = (63 * 40 * 6) = 3 1/2 -> 2^4 * 3^3 * 5 * 7 4320 = 2^5 * 3^3 * 5 2 [2] 24 [2, 2, 2, 3] 4320 [2, 2, 2, 2, 2, 3, 3, 3, 5] 4680 [2, 2, 2, 3, 3, 5, 13] 26208 [2, 2, 2, 2, 2, 3, 3, 7, 13]
import time start = time.time() from math import * fa = factorial from primes import factor size = 20 def log10(n): return log(n)/log(10) total = sum([log(n) for n in range(2,size+1)]) total = int(1000*total+.5)/1000. vals = [int(1000*log(n)+.5)/1000. for n in factor(fa(size))[:-1]] print total print vals, sum(vals) goal_val = total/3. prev_seen = {} def helper(n,pos): if (n,pos) in prev_seen: return prev_seen[(n,pos)] #base case if pos >= len(vals) or n >= goal_val: return n a = abs(goal_val - helper(n+vals[pos],pos+1))
import primes, sys print primes.factor(int(sys.argv[1]))
def factorAndAddToDict(num, valueDict): factors = factor(num) for num in factors: valueDict[num] += 1
l[i] += 1 for i in xrange(1, length): if l[i] > 10 - length + i: l[i] = l[i-1] + 1 yield l * 1 answers = set([]) unique_ascending_lists = lister(4) for unique_ascending_list in unique_ascending_lists: unique_lists = permutations(unique_ascending_list) for unique_list in unique_lists: number = digits.collapse(unique_list) ps = set(unique_list) # print "number: %s" % number factors = primes.factor(number) # print "factors: %s" % factors factorpairs = divisions(factors) # print unique_list for pair in factorpairs: # print " %s" % (pair,) multiplicand = functools.reduce(operator.mul, pair[0], 1) m1s = set(digits.get_all(multiplicand)) multiplier = functools.reduce(operator.mul, pair[1], 1) m2s = set(digits.get_all(multiplier)) if len(m1s) + len(m2s) == 5 and m1s | m2s | ps == set([1,2,3,4,5,6,7,8,9]): answers.add((multiplicand, multiplier, number)) pprint(answers) print sum(set(eq[2] for eq in answers))
#NOTE TODO need to solve it import time START = time.time() from primes import factor factorsDict = { \ 2 : 9, \ 3 : 5, \ 7 : 1, \ 11: 1 } factors = [] for f in factorsDict.keys(): factors += [f] * factorsDict[f] divisors = {2} for f in factors: divisors = set([x * f for x in divisors] + list(divisors)) print len(divisors) for d in divisors: if d % 100 == 12: print d, factor(d) print "Time taken:", time.time() - START
# 303963552391 # import numpy as np import primes primes.import_primes() set_size = 0 for d in range(2, 1000001): if d % 10000 == 0: print(d) factors = primes.factor(d) coprimes_per_cycle = 1 for factor in factors: coprimes_per_cycle *= factor - 1 set_size += d * coprimes_per_cycle / np.prod(factors) print(set_size)
import primes factors = primes.factor(600851475143) print max(factors)
#NOTE TODO need to solve it import time START = time.time() from math import * fa = factorial from primes import factor def sum10(abc): sumz = 10 ** (abc[0] / log_err) sumz += 10 ** (abc[1] / log_err) return sumz + 10 ** (abc[2] / log_err) size = fa(20) #2 * 3 * 5 * 7 * 11 log_err = 1000. vals = factor(size)[:-1] vals = [int(log_err * log(val,10)) for val in vals] total = sum(vals) prev = {} min_val = [10 ** 20] def helper(a, b, c, pos): if sum10((a, b, c)) > min_val[0]: return (float('inf'), float('inf'), float('inf')) #end of array if pos == len(vals): if sum10((a, b, c)) < min_val[0]:
import time START = time.time() from math import * fa = factorial from primes import factor def sum10(abc): sumz = 10**(abc[0] / log_err) sumz += 10**(abc[1] / log_err) return sumz + 10**(abc[2] / log_err) size = fa(20) #2 * 3 * 5 * 7 * 11 log_err = 1000. vals = factor(size)[:-1] vals = [int(log_err * log(val, 10)) for val in vals] total = sum(vals) prev = {} min_val = [10**20] def helper(a, b, c, pos): if sum10((a, b, c)) > min_val[0]: return (float('inf'), float('inf'), float('inf')) #end of array if pos == len(vals): if sum10((a, b, c)) < min_val[0]:
return prod ###### Attempting to short cut out of any solutions that aren't optimal... =/... prod2 = prod for i in prime_lst[pos:] : prod2 *= i if prod2*1.0 / lim < ratio: return -1 no_add = recurse(prod,pos+1, prime_lst, lim, ratio) added = recurse(prod * prime_lst[pos], pos+1,prime_lst, lim, ratio) val_no_add, val_add = lim - no_add, lim - added if val_no_add < val_add: return no_add return added ratio = .5 for iteration in xrange(1,len(PROD_LIM)): ans = recurse(1,0, prime_list[:iteration],PROD_LIM[iteration], ratio) print "The optimal answer is:", PROD_LIM[iteration], prime_list[iteration-1], iteration print "The answer is:", ans, factor(ans) print "The new ratio is:", ratio print "Time now is:", time.time() - START, '\n' ratio = ans*1.0/PROD_LIM[iteration] print "Time Taken:", time.time() - start
part_removed = sum_sq(start / 2, end / 2) * 8 return initial_sum - part_removed - P(f, 1) return (f + ((f + 1) % 2) + r - 2)**2 - P( f, r - 1) # was lazy only wanted to compute on case. """ These are the test cases to make sure I was getting the expected result:""" print "P(1,1) is:", P(1, 1) == 1 print "P(1,2) is:", P(1, 2) == 3 print "P(2,1) is:", P(2, 1) == 2 print "P(10,20) is:", P(10, 20) == 440 print "P(25,75) is:", P(25, 75) == 4863 print "P(99,100) is:", P(99, 100) == 19454 large_num = 71328803586048 #Given input number, not something I made up. factors = factor(large_num) print "factorized 71328803586048", factors vals = {2: 0, 3: 0, 1: 0} for i in factors: vals[i] += 1 print vals sumz = 0 for i in xrange(vals[2] + 1): for j in xrange(vals[3] + 1): n = 2**i * 3**j m = large_num / n sumz += P(n, m)
#NOTE TODO need to solve it import time START = time.time() from primes import factor factorsDict = { \ 2 : 9, \ 3 : 5, \ 7 : 1, \ 11: 1 } factors = [] for f in factorsDict.keys(): factors += [f] * factorsDict[f] divisors = {2} for f in factors: divisors = set( [x * f for x in divisors] + list(divisors)) print len(divisors) for d in divisors: if d % 100 == 12: print d, factor(d) print "Time taken:", time.time() - START
644 = 2^2 x 7 x 23 645 = 3 x 5 x 43 646 = 2 x 17 x 19. Find the first four consecutive integers to have four distinct primes factors. What is the first of these numbers? """ from primes import factor def find_consecutive_n_factor_integers(goal): n = 1 in_a_row = 0 while in_a_row < goal: factors = factor(n) if len(factors) == goal: in_a_row += 1 else: in_a_row = 0 n += 1 return n - goal if __name__ == '__main__': goal = 4 n = find_consecutive_n_factor_integers(goal) print 'Number\tFactors' for offset in range(0, goal): print "%d\t%s" % (n + offset, str(factor(n + offset)))
if gainsDict[otherNum][1] == n: merged.add(n**gainsDict[n][2] * otherNum**gainsDict[otherNum][2]) unusedNum.remove(n) unusedNum.remove(otherNum) errors = True while errors: errors = False for m1 in sorted(merged): if m1 not in merged: continue for m2 in sorted(merged): if m2 not in merged or m1 not in merged: continue f1 = factor(m1) f2 = factor(m2) m11, m12 = f1[0], f1[-1] m21, m22 = f2[0], f2[-1] m21Pow = int(math.log(SIZE * 1.0 / m12, m21)) m11Pow = int(math.log(SIZE * 1.0 / m22, m11)) if m1 + m2 < m11**m11Pow * m22 + m21**m21Pow * m12: errors = True merged.remove(m1) merged.remove(m2) merged.add(m11**m11Pow * m22) merged.add(m21**m21Pow * m12) print "Fixed:", m1, m2, m11, m12, m21, m22 print sum(forSureNum) + sum(merged)
import time from primes import gcd, m_r, factor START = time.time() SIZE = 100 sumz = 0 for i in xrange(1, SIZE + 1): factors = factor(i + 1) + factor(i**2 - i + 1) biggestFactor = sorted(factors)[-1] print i, biggestFactor sumz += biggestFactor - 1 print "Answer:", sumz print "Time Taken:", time.time() - START """ Congratulations, the answer you gave to problem 343 is correct. You are the 930th person to have solved this problem. Answer: 269533451410884183 Time Taken: 1570.37111306 Turns out that the 1/k fraction transforms into the (largest prime factor of k+1) - 1, so 1/6 -> 6, and 9 -> largestFactor(9+1) = 5 -> 4 """
def totient(n): fx = set(factor(n)) for x in fx: n *= (1 - 1.0 / x) return int(n)
import primes primes.init(10**4) for x in range(2,10**4): primes.factor(x)
The first three consecutive numbers to have three distinct prime factors are: 644 = 2^2 x 7 x 23 645 = 3 x 5 x 43 646 = 2 x 17 x 19. Find the first four consecutive integers to have four distinct primes factors. What is the first of these numbers? """ from primes import factor def find_consecutive_n_factor_integers(goal): n = 1 in_a_row = 0 while in_a_row < goal: factors = factor(n) if len(factors) == goal: in_a_row += 1 else: in_a_row = 0 n += 1 return n - goal if __name__ == '__main__': goal = 4 n = find_consecutive_n_factor_integers(goal) print 'Number\tFactors' for offset in range(0, goal): print "%d\t%s" % (n+offset, str(factor(n+offset)))
def get_divisors(factors): factors = filter(lambda x: x > 1, factors) divisors = set([1]) for f in factors: divisors = divisors.union(set([x * f for x in divisors])) return sorted(divisors) count = 0 for a in xrange(2, SIZE / 3): if math.sqrt(2 * a**2 + 1) + 2 * a > SIZE: break div = get_divisors(factor(a**2 + 1)) # a+b+c = a + (a^2 - 1)/k, which has to be less than the lim # also, c - b < a kLowerLim = (a**2 + 1) / (SIZE - a) div = filter(lambda k: k < a and k > kLowerLim, div) # b = (a^2 - k^2 - 1)/2k. We need to make sure b is an int # tangent: c = (a^2 + k^2 - 1)/2k. If b is an int, then so is c div = filter(lambda k: (a + k) % 2 == 1, div) div = filter(lambda k: \ (a % 2 == 0) or \ ((a**2 + 1) % (2*k) == 0) \ , div) # make sure that a <= b
import time from primes import divisors, factor, pfactor_gen START = time.time() SIZE = 10**6 factors = pfactor_gen(SIZE) for i in xrange(2,SIZE,2): if sum(divisors(i)) % i == i/2: print i, factor(i) print "Time Taken:", time.time() - START """ 2: 1,3,7,15,31,65,129 3: 1,4,10,40,121,364 5: 1,6,31,156,781,3906 p(2) = 3/2 -> 1 1/2 p(24) = (13 * 4)/8 = 6 1/2 p(4320) = (63 * 40 * 6) = 3 1/2 -> 2^4 * 3^3 * 5 * 7 4320 = 2^5 * 3^3 * 5 2 [2] 24 [2, 2, 2, 3] 4320 [2, 2, 2, 2, 2, 3, 3, 3, 5] 4680 [2, 2, 2, 3, 3, 5, 13]
if gainsDict[otherNum][1] == n: merged.add( n**gainsDict[n][2] * otherNum ** gainsDict[otherNum][2]) unusedNum.remove(n) unusedNum.remove(otherNum) errors = True while errors: errors = False for m1 in sorted(merged): if m1 not in merged: continue for m2 in sorted(merged): if m2 not in merged or m1 not in merged: continue f1 = factor(m1) f2 = factor(m2) m11, m12 = f1[0], f1[-1] m21, m22 = f2[0], f2[-1] m21Pow = int(math.log(SIZE*1.0/m12, m21)) m11Pow = int(math.log(SIZE*1.0/m22, m11)) if m1 + m2 < m11**m11Pow * m22 + m21 ** m21Pow * m12: errors = True merged.remove(m1) merged.remove(m2) merged.add(m11**m11Pow * m22) merged.add(m21**m21Pow * m12) print "Fixed:", m1, m2, m11, m12, m21, m22