def main():
prime = Prime()
prime_list = []
prime_under_one_million = []
for p in prime.get_prime():
if p < 1000:
prime_list.append(p)
prime_under_one_million.append(p)
elif p < 1000000:
prime_under_one_million.append(p)
else:
break
negative_prime_list = [0 - v for v in sorted(prime_list, reverse=True)]
negative_prime_list.extend(prime_list)
# b is try to be big, then n&b co efficient will be big
# a is try to be small, then
current_max_combination = 0
for a in negative_prime_list:
for b in negative_prime_list:
combi_cnt = 0
for n in count():
if n * n + a * n + b not in prime_under_one_million:
break
else:
combi_cnt += 1
if combi_cnt > current_max_combination:
print 'find an greater combination: a={}, b={} has {} combinations'.format(
a, b, combi_cnt)
current_max_combination = max(current_max_combination,
combi_cnt)
def ans():
for prime in Prime.gen_nums():
if prime < 120000:
continue
# Replace all combinations of digits
list_ = list(str(prime))
length = len(list_)
for count in range(length):
combs = combinations(range(length), count)
for indices in combs:
# Count the number of primes by replacing
# the selected digits with some other digit
generated_primes = set()
for replacement in range(10):
copy = list_.copy()
for i in indices:
copy[i] = str(replacement)
number = int(''.join(copy))
if Prime.contains(number):
generated_primes.add(number)
if 7 < len(generated_primes):
return min(generated_primes)
def Prime_div(num,Prime,divisors):
""" Recursively Finds the prime divisors of a given number,
Args:
num (int): Number whose Prive divisors will be calculated
Prime (Prime) : An instance of the Prime class used to generate primes
divisors (list): A list representing the divisors found so far
"""
if divisors == []: #if this is the first call add one to list all numbers div by 1
divisors.append(1)
if Prime.isPrime(num):#base case. when prime number is found we have found all Prime divisors
temp = divisors
divisors.append(num)
return divisors
else:# testing case. If we have not found our base prime, then we keep calling the function
Prime.reset()
factor = Prime.nextPrime()
found = False#Set to false in each call
while factor < num/2 and not found:
if num%factor == 0:
divisors.append(factor)#Appends a found prime divisor to our list
found = True
if not found:
factor = Prime.nextPrime()#Cycles through prime list until we find a prime the number is divisible by
return Prime_div(num/factor,Prime,divisors)
def main():
P = Prime()
tn_iterator = get_triangle_number()
while True:
triangle_number = tn_iterator.next()
count_of_divisors = P.get_count_of_divisors_by_number(triangle_number)
if 500 < count_of_divisors:
break
print triangle_number
def is_truncatable(n):
str_n = str(n)
if len(str_n) < 2:
return False
for i in range(1, len(str(n))):
if not Prime.contains(int(str_n[:i])):
return False
if not Prime.contains(int(str_n[i:])):
return False
return True
def ans():
size = 5
skip_to = 8300
for p in Prime.gen_nums():
if p < skip_to:
continue
nums = [q for q in Prime.gen_nums(p) if compatible(q, p)]
for tuple_ in combinations(nums, size - 1):
if remarkable(tuple_):
return p + sum(tuple_)
def ans():
prime_list = list(Prime.gen_nums(4000))
longest = (0, 0)
for i in range(len(prime_list)):
sum_ = 0
for j in range(i, len(prime_list)):
sum_ += prime_list[j]
if 1000000 <= sum_:
break
if Prime.contains(sum_) and longest[1] < j - i + 1:
longest = (sum_, j - i + 1)
return longest[0]
class PrimeTest(unittest.TestCase):
# set up variables that we will use globally
def setUp(self):
self.prime = Prime()
def test_invalid_input(self):
result = self.prime.primeNumbers("string")
self.assertEqual(result, 'Input value should be an Integer',
'Input allows invalid input')
def test_that_input_should_be_greater_than_1(self):
result = self.prime.primeNumbers(1)
self.assertEqual(result, 'Input should be a number greater than 1',
'Input allows incorrect values')
def test_that_float_inputs_are_rounded_to_next_whole_number(self):
result = self.prime.primeNumbers(36.7)
self.assertEqual(result, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37],
'Floats give incorrect output')
def test_function_gives_correct_output_with_2(self):
result = self.prime.primeNumbers(2)
self.assertEqual(result, [2], 'Incorrect output')
def test_function_gives_correct_output_with_3(self):
result = self.prime.primeNumbers(3)
self.assertEqual(result, [2, 3], 'Incorrect output')
def test_function_gives_correct_output_with_15(self):
result = self.prime.primeNumbers(15)
self.assertEqual(result, [2, 3, 5, 7, 11, 13], 'Incorrect output')
def test_function_gives_correct_output_with_60(self):
result = self.prime.primeNumbers(60)
self.assertEqual(
result,
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59],
'Incorrect output')
def test_function_gives_correct_output_with_20(self):
result = self.prime.primeNumbers(20)
self.assertEqual(result, [2, 3, 5, 7, 11, 13, 17, 19],
'Incorrect output')
def test_function_gives_correct_output_with_10(self):
result = self.prime.primeNumbers(10)
self.assertEqual(result, [2, 3, 5, 7], 'Incorrect output')
def test_function_gives_correct_output_with_float(self):
result = self.prime.primeNumbers(18.6)
self.assertEqual(result, [2, 3, 5, 7, 11, 13, 17, 19],
'Incorrect output')
def ans():
circular_primes = set([2])
for p in Prime.gen_nums(1000000):
if any(x in str(p) for x in '02468'):
continue
is_circular = True
for i in range(len(str(p))):
if not Prime.contains(int(str(p)[i:] + str(p)[:i])):
is_circular = False
break
if is_circular:
circular_primes.add(p)
return len(circular_primes)
def ans():
num = 9
while satisfies_conjecture(num):
num += 2
while Prime.contains(num):
num += 2
return num
def satisfies_conjecture(n):
root = 1
while 2 * root**2 < n:
if Prime.contains(n - 2 * root**2):
return True
root += 1
return False
def test_get_prime(self):
self.assertEqual(Prime.get_prime(0), 2)
self.assertEqual(Prime.get_prime(1), 3)
self.assertEqual(Prime.get_prime(2), 5)
self.assertEqual(Prime.get_prime(3), 7)
self.assertEqual(Prime.get_prime(4), 11)
self.assertEqual(Prime.get_prime(5), 13)
self.assertEqual(Prime.get_prime(6), 17)
self.assertEqual(Prime.get_prime(7), 19)
def ans():
n = 1
for p in Prime.gen_nums():
next_ = n * p
if 1000000 < next_:
return n
n = next_
return n
def ans():
truncatable = set()
for p in Prime.gen_nums():
if is_truncatable(p):
truncatable.add(p)
if len(truncatable) == 11:
break
return sum(truncatable)
def main(min_prime, max_prime):
"""Parse the args and if all is good, summon Prime to do the computation."""
logger.debug('Inside main()')
print('Calculating prime numbers between {} and {}'.format(
min_prime, max_prime))
primes = Prime().primes_between(start=min_prime, stop=max_prime)
print('Found {} prime numbers'.format(len(primes)))
print(primes)
def nextprime(np):
if (np <= 1):
return 2
prime = np
found = False
if (Prime(prime) == True):
return np
while (not found):
prime += 1
if (Prime(prime) == True):
found = True
return prime
def get_prime_factors(n):
""" Returns the counts of each prime factor of n
"""
if n < 1:
raise ValueError
if n == 1:
return Counter()
divisor = 2
while n % divisor != 0:
divisor = Prime.after(divisor)
return Counter({divisor: 1}) + get_prime_factors(n // divisor)
def ans():
lim = 1000
largest = (None, None, 0)
for a in range(-lim + 1, lim):
for b in range(-lim, lim + 1):
n = 0
while Prime.contains(f(n, a, b)):
n += 1
if largest[2] < n:
largest = (a, b, n)
return largest[0] * largest[1]
def ans():
groups = defaultdict(set)
for prime in Prime.gen_nums(10000):
groups[''.join(sorted(str(prime)))].add(prime)
for set_ in groups.values():
for comb in combinations(set_, 3):
seq = sorted(list(comb))
if seq[0] < 1000:
continue
if (seq[2] + seq[0] == 2 * seq[1] and seq[0] != 1487):
return ''.join(str(n) for n in seq)
class TestPrime(object):
"""Tests focused on the Prime class."""
def setup_method(self):
self.prime = Prime()
def test_prime_happy(self):
"""Test prime() method on the happy path."""
result = self.prime.primes()
assert result is not None
assert True
def test_prime_5(self):
""" Test prime(5) and make sure it returns [2, 3, 5]. """
result = self.prime.primes(stop=5)
assert len(result) == 3, 'list of primes was expected to have length 3'
assert result[0] == 2
assert result[1] == 3
assert result[2] == 5
def test_is_prime(self):
assert self.prime.is_prime(5)
assert self.prime.is_prime(7)
assert not self.prime.is_prime(500)
assert not self.prime.is_prime(280000)
def test_primes(self):
result = self.prime.primes(stop=100000)
print(result)
def test_primes_between(self):
result = self.prime.primes_between(1, 5)
expected_result = [2, 3]
assert result == expected_result, 'Expected list of primes did not match'
expected_result = [
7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
73, 79, 83, 89
]
result = self.prime.primes_between(5, 97)
assert result == expected_result, 'Expected list of primes did not match'
# When min and max yield an empty set, we should get an empty list
result = self.prime.primes_between(4, 5)
assert result == [], 'Result should have been an empty list'
def main():
prime_ins = Prime()
prime_hash = dict()
circular_prime_list = list()
for i in prime_ins.get_prime():
if i < TARGET:
prime_hash[i] = True
else:
break
for prime in prime_hash:
circular_list = []
for i in range(1, len(str(prime))):
circular_list.append(int(''.join(str(prime)[i:] + str(prime)[0:i])))
for num in circular_list:
if not num in prime_hash:
break
else:
print "circular prime found: {}".format(prime)
circular_prime_list.append(prime)
print "count of all circular prime is {}".format(len(circular_prime_list))
def ans():
divisors = list(Prime.gen_nums(18))
sum_ = 0
for p in gen_pandigitals(from_=0, to=9):
has_property = True
for i in range(1, 8):
dividend = int(str(p)[i:i + 3])
if dividend % divisors[i - 1] != 0:
has_property = False
break
if has_property:
sum_ += p
return sum_
def test_get_greatest_common_divisor(self):
self.assertEqual(
Prime.get_greatest_common_divisor(3 * 5 * 7 * 7 * 11,
5 * 7 * 11 * 11 * 13),
5 * 7 * 11)
self.assertEqual(Prime.get_greatest_common_divisor(1, 2), 1)
self.assertEqual(Prime.get_greatest_common_divisor(-1, 2), 1)
self.assertEqual(Prime.get_greatest_common_divisor(-1, -2), 1)
self.assertEqual(Prime.get_greatest_common_divisor(2, -1), 1)
self.assertEqual(Prime.get_greatest_common_divisor(-2, 1), 1)
self.assertEqual(Prime.get_greatest_common_divisor(-2, -1), 1)
def test_get_prime_factors(self):
self.assertRaises(ValueError, lambda: Prime.get_prime_factors(1))
self.assertRaises(ValueError, lambda: Prime.get_prime_factors(0))
self.assertRaises(ValueError, lambda: Prime.get_prime_factors(-1))
self.assertRaises(ValueError, lambda: Prime.get_prime_factors(-3))
self.assertListEqual(Prime.get_prime_factors(2), [2])
self.assertListEqual(Prime.get_prime_factors(2 * 3 * 5 * 7 * 7 * 11),
[2, 3, 5, 7, 7, 11])
class TestPrime(unittest.TestCase):
def setUp(self):
self.prime = Prime()
def test_prime_returns_error_if_arg_is_not_positive_integer(self):
self.assertRaises(TypeError, self.prime.prime, -10)
def test_prime_returns_error_message_if_arg_is_string(self):
self.assertRaises(TypeError, self.prime.prime, '10')
def test_prime_returns_error_message_if_arg_is_float(self):
self.assertRaises(TypeError, self.prime.prime, 10.0)
def test_prime_returns_empty_list_when_arg_is_0(self):
result = self.prime.prime(0)
self.assertEqual([], result)
def test_prime_returns_2_when_arg_is_2(self):
result = self.prime.prime(2)
self.assertEqual(2, result)
if __name__ == '--main--':
unittest.main()
def ans():
diags = gen_diagonals()
next(diags)
i = 1
prime_count = 0
total_count = 1
while True:
for n in next(diags):
if Prime.contains(n):
prime_count += 1
total_count += 1
i += 2
if prime_count / total_count < .1:
break
return i
def ans():
# The insight is that n / phi(n) is minimized when n has a few, large prime
# factors (n can't be prime, since prime numbers don't satisfy the
# permutation criteria). Also, note that we don't actually have to compute
# all of the numbers coprime with n to determine phi(n); instead we can use
# the fact that n is a product of two primes to calculate phi(n) in
# constant time.
min_n = None
min_value = None
primes = Prime.gen_nums(10**4)
combos = combinations(primes, 2)
for one, two in list(combos):
n = one * two
if 10**7 <= n:
continue
num_coprimes = one * two - one - two + 1
if sorted(str(n)) == sorted(str(num_coprimes)):
value = n / num_coprimes
if not min_value or value < min_value:
min_n = n
min_value = value
return min_n
#!/usr/bin/python
#
# Author: Ryan Scott
# Purpose: Solve problem 007 of the Euler Project
# Assumes: Python 2.7
#
# By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.
# What is the 10 001st prime number?
from prime import Prime
prime = Prime()
prime_count = 6 # given by problem
num = 14 # next number to try
while True:
if prime.is_prime(num):
prime_count += 1
if 10001 == prime_count:
break
num += 1
print str(num - 1)
#!/usr/bin/python import math from math import * import itertools import decimal from decimal import * from collections import deque from prime import Prime p = Prime() L = p.factorize(644) print L for i in range(100000,150000): fac1=len(sorted(set(p.factorize(i)))) if(fac1==4): fac2=len(sorted(set((p.factorize(i-1))))) if(fac2==4): fac3=len(sorted(set((p.factorize(i-2))))) if(fac3==4): fac4=len(sorted(set((p.factorize(i-3))))) if(fac4==4): print i,i-1,i-2,i-3 print p.factorize(i) print p.factorize(i-1) print p.factorize(i-2) print p.factorize(i-3) break
return True else: return False def divisors(n): div=[] for i in range (2,int(math.sqrt(n))+1): if(n%i==0): if(n/i != i): div.append(i) div.append(n/i) else: div.append(i) return div p = Prime() primes=[] nfn=[] def ffn(n): if p.factor(n)==None: return (n/((n-1)*1.0),n-1,n,0,[]) else: div=divisors(n) f=n j=0 factors=[] for d in div: if p.factor(d)==None: f=f/d f*=(d-1) factors.append(d)
#!/usr/bin/python import math from math import * import itertools import decimal from decimal import * from collections import deque from prime import Prime import operator import string from sets import Set p = Prime() primes=[] j=0 for i in range(2,2000): if(p.factor(i)==None): primes.append(i) if i==4159: print j j+=1 def removeFromList(n,l): lis=[] for iL in range(0,len(l)): if(n == l[iL]): lis=l[:iL]+l[iL+1:] return lis def checkNums(n1,n2):
from prime import Prime p = Prime() f = p.factor(45) L = p.factorize(45) print f,L
#!/usr/bin/python import math from math import * import itertools import decimal from decimal import * from collections import deque from prime import Prime import operator import string from sets import Set p = Prime() primes=[] j=0 for i in range(2,2000): if(p.factor(i)==None): primes.append(i) if i==4159: print j j+=1 def removeFromList(n,l): lis=[] for iL in range(0,len(l)): if(n == l[iL]): lis=l[:iL]+l[iL+1:] return lis def checkNums(n1,n2): str1=str(n1)
#!/usr/bin/python import math from math import * import itertools import decimal from decimal import * from collections import deque from prime import Prime p = Prime() num=1 sumtotal=1 diagonals=[] diagPrimes=[] for x in range(1,15000): for y in range(1,5): num=num+2*x diagonals.append(num) if p.factor(num)==None: diagPrimes.append(num) if(len(diagPrimes)*(1.0)/(len(diagonals)+1)*(1.0))<0.10: print num**0.5 break
##The number 3797 has an interesting property. Being prime itself, it is possible to continuously remove ##
##digits from left to right, and remain prime at each stage: 3797, 797, 97, and 7.##
## Similarly we can work from right to left: 3797, 379, 37, and 3. ##
## Find the sum of the only eleven primes that are both truncatable from ##
##left to right and right to left. ##
## NOTE: 2, 3, 5, and 7 are not considered to be truncatable primes. ##
from prime import Prime
p = Prime()
def truncatableprime(n):
## from left to right ##
for i in range(len(str(n))):
if not p.isprime(int(str(n)[i:])):
return False
## from right to left
tmp = n
while tmp>0:
if not p.isprime(tmp):
return False
tmp = tmp/10
return True
count = 1
n = 10
sumofTP = 0
def main():
P = Prime()
prime_factors = P.get_prime_factors_by_number(600851475143)
print(max(prime_factors.keys()))
class Divisor:
def __init__(self,):
self.__mod_prime = Prime()
self.__mod_permutation = Permutation()
def get_count_of_divisors(self, n):
"""
>>> D = Divisor()
>>> D.get_count_of_divisors(2)
2
>>> D.get_count_of_divisors(100)
9
>>> D.get_count_of_divisors(-1)
Traceback (most recent call last):
ValueError: input has to be a positive int or long: -1
"""
if isinstance(n, (int, long)) == False or n <= 0:
raise ValueError("input has to be a positive int or long: %s" %n)
if n == 1:
return 1
# n = (a ** p) * (b ** q) * (c ** r) のとき、
# n の約数は (p + 1) * (q + 1) * (r + 1) で求められる
factors = self.__mod_prime.get_prime_factors(n)
powers = [v + 1 for v in factors.values()] # [p+1, q+1, r+1, ...]
return reduce(lambda x, y: x * y, powers)
def get_proper_divisors(self, n, n_large = 2000):
"""
>>> D = Divisor()
>>> D.get_proper_divisors(28)
[1, 2, 4, 7, 14]
>>> D.get_proper_divisors(200)
[1, 2, 4, 5, 8, 10, 20, 25, 40, 50, 100]
"""
if n >= n_large:
return self._get_pds1(n)
else:
return self._get_pds2(n)
def _get_pds1(self, n):
prime_factors = self.__mod_prime.get_prime_factors(n)
# prime_all_powers
prime_all_powers = {}
# for n=600 primes = [2, 3, 5]
for prime,power in prime_factors.items(): # for n=200 prime=2,5
prime_all_powers[prime] = [prime * pw for pw in range(power)]
# for n=600 prime_all_powers = {2:[1,2,4,8], 3:[1,3], 5:[1,5,25]}
res = []
for pair in self.__mod_permutation.get_all_permutations(prime_all_powers.values()):
# pairs: [1,1,1], [1,1,5], [1,1,25], [1,3,1], [1,3,5], [1,3,25], .... [8,3,25]
res.append( reduce(lambda x,y: int(x)*int(y), pair) )
return res
def _get_pds2(self, n):
pds = []
for i in range(1, int(n / 2) + 1):
if n % i == 0:
pds.append( i )
return pds
def __init__(self,):
self.__mod_prime = Prime()
self.__mod_permutation = Permutation()
from math import *
import itertools
import decimal
from decimal import *
from collections import deque
from prime import Prime
def tupleToStr(t):
i=0
s=""
while(i<len(t)):
s+=str(t[i])
i+=1
return s
p = Prime()
L = p.factorize(644)
print tupleToStr(list(itertools.permutations("1234"))[0])
def isPerm(n1,n2,n3):
permsN1=list(itertools.permutations(str(n1)))
size=len(permsN1)
perms=[]
for i in range(0,size):
perms.append(int(tupleToStr(permsN1[i])))
if(n2 in perms and n3 in perms):
print n1,n2,n3
isPerm(1487,4817,8147)
def test_prime(self):
"""."""
self.assertEqual(bool(Prime(7)), True)
self.assertEqual(bool(Prime(6)), False)
from prime import Prime
import itertools
import sys
p = Pandigital()
result = None
numbers = '987654321'
for n in range(0,6):
number = numbers[n:]
for perm in itertools.permutations(number, len(number)):
candidate = int(''.join(perm))
if Prime.isprime(int(candidate)):
result = candidate
break
if (result != None):
break
print result
import operator import string from sets import Set def divisors(n): div=[] for i in range (2,int(math.sqrt(n))+1): if(n%i==0): if(n/i != i): div.append(i) div.append(n/i) else: div.append(i) return div p = Prime() primes=[] nfn=[] for n in range(2,1000001): if p.factor(n)==None: nfn.append((n/((n-1)*1.0),n)) else: div=divisors(n) f=n for d in div: if p.factor(d)==None: f=f/d f*=(d-1) nfn.append((n/(f*1.0),n)) print max(nfn)
#!/usr/bin/python import math from math import * import itertools import decimal from decimal import * from collections import deque from prime import Prime p = Prime() L = p.factorize(644) primes=[] for i in range(2,10000): if p.factor(i)==None: primes.append(i) sum=0 i=0 j=0 for j in range(0,60): max=600 while(max>0): i=j while(i<max+j): sum+=primes[i] i+=1 if(p.factor(sum)==None and sum>900000 and sum<1000000): print sum,i-1-j max-=1 sum=0
def main():
P = Prime()
primes = P.get_primes_by_index(10001)
print primes[-1]
def ans():
num = 600851475143
end = int(sqrt(num)) + 1
for i in reversed(range(2, end)):
if num % i == 0 and Prime.contains(i):
return i
import sys
import copy
import math
from collections import deque
from prime import Prime
prime_man = Prime()
#obtain the name of the input
def fileName():
filename = 'input'
if len(sys.argv) > 1:
filename = sys.argv[1]
else:
print("File was not indicated")
exit()
return filename
fn = fileName()
file = open(fn, 'r')
out = open('output', 'w')
line_number = 1;
testcase = 1
max_testcases = 0
tc_ln = 0
while True:
line = file.readline()
if line:
line = line.replace("\n","")
inputs = line.split(" ")
from prime import Prime
longest = 0
ans = 0
Prime.isPrime(1000000)
for i in range(0, len(Prime.p)):
curr = 0
value = 0
for j in range(i, len(Prime.p)):
curr += 1
value += Prime.p[j]
if value > 1000000:
break
if Prime.isPrime(value) and curr > longest:
longest = curr
ans = value
if longest >= curr:
break
print(ans)
#!/usr/bin/python
#
# Author: Ryan Scott
# Purpose: Solve problem 003 of the Euler Project
# Assumes: Python 2.7
#
# The prime factors of 13195 are 5, 7, 13 and 29.
# What is the largest prime factor of the number 600851475143 ?
from prime import Prime
import math
num = 600851475143
# keep track of state through loop
largest_prime_divisor = 0
prime = Prime()
for possible_divisor in range(2, int(math.ceil(math.sqrt(num)))):
if 0 == num % possible_divisor and prime.is_prime(possible_divisor):
if possible_divisor > largest_prime_divisor:
largest_prime_divisor = possible_divisor
print str(largest_prime_divisor)
from prime import Prime
target = int(5e7)
mask = [1] * target
ans = 0
for i in map(lambda x: x**2, Prime.prime()):
if i >= target:
break
for j in map(lambda x: x**3, Prime.prime()):
if i + j >= target:
break
for k in map(lambda x: x**4, Prime.prime()):
s = i + j + k
if s >= target:
break
ans += mask[s]
mask[s] = 0
print(ans)
def main():
P = Prime()
print sum(P.get_primes_by_upper_limit(2000000))
def main():
P = Prime()
print sum(P.get_primes_by_limit_number(2000000))
