def main():
# Pide un número al usuario
user_number = input(f"Introduce un número: ")
number = fraction.convert_to_float(user_number)
if not number:
console.show_error("Debes introducir un número.")
return
if validation.is_valid(number):
# Obtiene el denominador y el numerador del número con decimales
(numerator, denominator) = fraction.get_fractional_parts(number)
# Obtiene una lista con los números primos
primes_list = primes.get_primes(int(denominator / 2))
# Reduce el numerador y denominador
(reduced_numerator, reduced_denominator) = fraction.reduce_fraction(
numerator, denominator, primes_list)
# Muestra el resultado
console.show_info(
f"Valor inicial: {number}\nValor final: {reduced_numerator}/{reduced_denominator}"
)
def factorisation_with_primes(n, factors=[]):
for i in get_primes(last=n // 2 + 1):
if n == 1:
return factors
while n % i == 0:
factors.append(i)
n /= i
def get_prod_list(num):
primes = get_primes(1000)
possible_prod_dict = dict()
non_prod_dict = dict()
for a in range(1, num):
for b in range(a, num):
prod = a * b
print("calculating product pairs (", a, b, ")", end="\r")
if a * b == 1:
possible_prod_dict[1] = {(1, 1)}
continue
prime_factor_list = get_prime_factors(primes, prod)
partition_list = get_partitions(prime_factor_list)
possible_factors = set()
for (x, y) in partition_list:
num1 = reduce(lambda u, v: u * v, x, 1)
num2 = reduce(lambda u, v: u * v, y, 1)
if num2 >= num1:
temp_pair = (num1, num2)
else:
temp_pair = (num2, num1)
# print(num1,num2)
possible_factors.add(temp_pair)
possible_prod_dict[a * b] = possible_factors
# print(possible_prod_dict)
# assert False
return possible_prod_dict
def generate_rsa():
primes = get_primes(100)
primes_count = len(primes)
p = primes[int(random() * primes_count)]
q = primes[int(random() * primes_count)]
print p, q
n = p * q
etf = (p-1)*(q-1)
print etf
coprimes = get_coprimes(etf)
print coprimes
e = coprimes[int(len(coprimes)*random())]
#d is the modular multiplicative inverse
#http://stackoverflow.com/questions/4798654/modular-multiplicative-inverse-function-in-python
d = (pow(e, etf-2, etf)*e) % etf
print e, d
return {
'q': q,
'p': p,
'n': n,
'etf':etf,
'e':e,
'd':d,
'public':str(n)+'-'+str(e),
'private':str(n)+'-'+str(d)
}
def is_goldbach(n):
for p in get_primes(n):
x = math.sqrt((n-p)/2)
if int(x)==x:
# n = p + 2*x^2
return int(x)
return None
def primes_func(n, m):
'''
Get all primes between n and m
'''
all_primes = get_primes(m)
i = 0
while all_primes[i] < n:
i += 1
return all_primes[i::]
def get_primes_less_than(number):
primes = get_primes()
while True:
current_prime = primes.next()
if current_prime > number:
break
else:
yield current_prime
def prod_greater_1000(sum):
primes_list = get_primes(2000)
sum_feasible = True
for a in range(1, int(sum / 2) + 1):
b = sum - a
if a in primes_list and b in primes_list and a * b > 1000:
sum_feasible = False
break
return sum_feasible, a, b
def solution(show_result=False):
# seed prime factory
digits = '123456789'
list(get_primes(10000))
for attempt in combinations_with_replacement(digits, 4):
sequence = unusual_sequence(attempt)
if sequence:
if show_result:
print sequence
if sequence[0]!=1487:
return ''.join(map(str, sequence))
pass
def prime_factors(number):
" Return a generator with all the prime factors of the input number "
primes = get_primes()
current_prime = primes.next()
while current_prime < math.sqrt(number):
if number % current_prime == 0:
yield current_prime
current_prime = primes.next()
raise StopIteration
def direct(n):
p = get_primes(last=n)
mmin = 1
for i in p:
mmin *= i
while True:
for i in range(1, n + 1):
if mmin % i != 0:
mmin += 1
break
else:
return mmin
def main():
limit = 1000000
primes = [p for p in get_primes(limit) if p > 99999]
for p in primes:
n = has_three_repeating_digits(p)
if n:
li = [str(i) for i in range(int(n)+1, 10)]
s = str(p)
series = [p]
for el in li:
i = int(s.replace(n,el))
if i in primes:
series.append(i)
if len(series) == 8:
print p
return
def solution():
N = 1000
best_length, best_a, best_b = 0, 0, 0
# b can't be negative, and for n=0, it has to be a prime
for b in reversed(list(get_primes(N))):
# n^2 + an + b is a multiple of b if n==b,
# so quadratics_length(a,b) <= b
if b < best_length:
break
for a_abs in range(1,N,2):
for a in (a_abs, -a_abs):
if not is_prime(best_length*best_length + a*best_length + b):
# quadratics_length(a, b) <= best_length, so skip
continue
length = quadratics_length(a, b)
if length > best_length:
best_length, best_a, best_b = length, a, b
return best_a * best_b
def get_sum():
primes_list = get_primes(2000)
print(primes_list)
sum_list = []
non_sum_list = dict()
for sum in range(3, 2001):
# is sum = 1 + prime then exclude
sum_feasible = True
if sum - 1 in primes_list:
non_sum_list[sum] = [sum - 1]
continue
# if sum = p1 + p2 st p1xp2 > 1000 then exclude
sum_feasible, a, b = prod_greater_1000(sum)
if sum_feasible:
sum_list.append(sum)
else:
non_sum_list[sum] = [a, b]
return sum_list, non_sum_list
def solution():
N = 10001
return next(itertools.islice(get_primes(), N-1, N))
import time, math
from primes import get_primes
START = time.time()
NUM_PRIMES = 47
LIM = 10**12 * 2
small_primes = get_primes(NUM_PRIMES)
smooths = set([1])
for p in small_primes:
next_batch = set(filter(lambda y: y <= LIM, [p * x for x in smooths]))
smooths.update(next_batch)
for power in xrange(2, int(math.log(LIM, p)) + 1):
next_batch = set(
filter(lambda y: y <= LIM, [p * x for x in next_batch]))
smooths.update(next_batch)
print "Time Taken:", time.time() - START
sumz = 0
for num in smooths:
if num + 1 in smooths:
sumz += num
print "Answer is:", sumz
print "Time Taken:", time.time() - START
"""
Congratulations, the answer you gave to problem 581 is correct.
You are the 81st person to have solved this problem.
# Largest Prime Factor
from primes import get_primes
from math import sqrt
N = 600851475143
n = int(sqrt(N))
pr = get_primes(n)
i = len(pr) - 1
while i > 0:
if N % pr[i] == 0:
print(pr[i])
break
i -= 1
import time
from primes import get_primes
START = time.time()
SIZE = 10**5 * 25
primes = get_primes(SIZE * 40)
coords = [(primes[0], primes[0])]
print "Time Taken:", time.time() - START
for i in xrange(1, SIZE):
coords.append( (coords[-1][0] + primes[2*i] + primes[2*i-1], \
coords[-1][1] + primes[2*i] - primes[2*i-1]) \
)
totalCount = 1
maxDiff = 10
for currentPeakIndex in xrange(1, SIZE):
if currentPeakIndex % 10**5 == 0:
print currentPeakIndex, time.time() - START
currentPeak = coords[currentPeakIndex]
peakCount = 0
viewAngle = 1
for prevPeakIndex in xrange(
currentPeakIndex - 1,
currentPeakIndex - min(currentPeakIndex, maxDiff * 2), -1):
prevPeak = coords[prevPeakIndex]
nextAngle = (1.0 * currentPeak[1] - prevPeak[1]) / (currentPeak[0] -
prevPeak[0])
if nextAngle < viewAngle:
peakCount += 1
# have b go through list of primes for 1 to 1000
# have a go from -b to 1000
# factor f(n)=n^2+an+b
# get minimum positive root (if it exists)
# check if that number is greater than current maximum
# if it is, start going through f(n) for n=0,1,2,... and find first non-prime
def is_prime(num):
if all(mod(num, range(1, int(sqrt(num)) + 1))):
return True
return False
max_prime = 1000
primes, max_prime = get_primes(1000)
not_primes = delete(arange(0, 1000), primes)
maxn = 40
maxp = 41
for b in primes[primes < 1000]:
for a in range(-b, 1001):
if a**2 - 4 * b >= 0 and (-a - sqrt(a**2 - 4 * b)) / 2 > 0 and (
-a - sqrt(a**2 - 4 * b)) / 2 < maxn:
continue
n = -1
while True:
n += 1
import time, math
from primes import get_primes
START = time.time()
SIZE = 10**6
MAX_THREE_POW = int(math.log(SIZE,3))+1
primes = get_primes(SIZE)
def incrValDict(valDict, value):
if value in valDict:
valDict[value] += 1
else:
valDict[value] = 1
values = dict()
def recurse(threePow, twoPow, runningSum):
if threePow >= MAX_THREE_POW:
incrValDict(values, runningSum)
return
for i in xrange(0, twoPow):
nextPartitionItem = 2**i * 3**threePow
if nextPartitionItem + runningSum > SIZE:
break
recurse( threePow +1, i, runningSum + nextPartitionItem)
recurse(threePow +1, twoPow, runningSum)
recurse(0, int(math.log(SIZE, 2) + 1), 0)
sumz = 0
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.path.append('../lib')
from primes import get_primes
primes = get_primes()
prime = None
for i in range(10001):
prime = primes.next()
print prime
# p27.py
# created 2017.05.13 by tom and stacy <3
from numpy import *
from primes import get_primes
# have b go through list of primes for 1 to 1000
# have a go from -b to 1000
# factor f(n)=n^2+an+b
# get minimum positive root (if it exists)
# check if that number is greater than current maximum
# if it is, start going through f(n) for n=0,1,2,... and find first non-prime
max_prime = 1000
primes, max_prime = get_primes(1000)
maxn = 40
maxp = 41
for b in primes[primes < 1000]:
for a in range(-b, 1001):
if a**2 - 4 * b >= 0 and (-a - sqrt(a**2 - 4 * b)) / 2 > 0 and (
-a - sqrt(a**2 - 4 * b)) / 2 < maxn:
continue
#quadratic=arange(maxn)**2+a*arange(maxn)+b
#for inum,num in enumerate(quadratic):
n = -1
while True:
n += 1
num = n**2 + a * n + b
if num <= 0: break
if num > max_prime: primes, max_prime = get_primes(num)
import time
from primes import factor, get_primes
START = time.time()
SIZE = 100
primes = get_primes(SIZE)[::-1]
LIM = reduce(lambda x, y: x * y, primes)**.5
def prod(lst):
if lst == []:
return 1
return reduce(lambda x, y: x * y, lst)
valid_set = set([1])
for index in xrange(len(primes)):
prime = primes[index]
remainingProd = prod(primes[index + 1:])
maxElem = max(valid_set)
print prime, len(valid_set), "Time Taken:", time.time() - START
valid_set.update( \
set(filter(lambda x: x < LIM and x * remainingProd > maxElem, \
[prime * val for val in valid_set])))
valid_set = set(
filter(lambda x: x < LIM and x * remainingProd >= maxElem, valid_set))
print LIM - max(valid_set)
print "Time Taken:", time.time() - START
import time, math
from primes import get_primes
START = time.time()
NUM_PRIMES = 47
LIM = 10**12 * 2
small_primes = get_primes(NUM_PRIMES)
smooths = set([1])
for p in small_primes:
next_batch = set( filter(lambda y: y <= LIM, [p * x for x in smooths]))
smooths.update(next_batch)
for power in xrange(2, int(math.log(LIM, p))+1):
next_batch = set( filter(lambda y: y <= LIM, [p * x for x in next_batch]))
smooths.update(next_batch)
print "Time Taken:", time.time() - START
sumz = 0
for num in smooths:
if num+1 in smooths:
sumz += num
print "Answer is:", sumz
print "Time Taken:", time.time() - START
"""
Congratulations, the answer you gave to problem 581 is correct.
You are the 81st person to have solved this problem.
#NOTE TODO need to solve it
import time
from primes import get_primes
START = time.time()
g = 0.0001
n = 100
primes = get_primes(n)
def splitIntervals(intervals, pos):
for index, interval in enumerate(intervals):
if interval[0] < pos < interval[1]:
if interval[1] - pos > g:
intervals.append((pos, interval[1]))
if pos - interval[0] > g:
intervals[index] = (interval[0], pos)
else:
del intervals[index]
intervals.sort()
break
for p in primes:
intervals = [(0, 1)]
for jump in xrange(1, int(10 / g)):
splitIntervals(intervals, ((1. / p)**.5 * jump) % 1)
#print jump, len(intervals), ((1./p)**.5 * jump) % 1
#print '\t', [(round(x[0],4),round(x[1],4)) for x in intervals]
if len(intervals) == 0:
print p, jump
import time
from primes import get_primes
START = time.time()
MOD = 10**16
prime_lst = sorted(get_primes(5000))
print "Time Taken: ", time.time() - START
prime_set2 = set([2])
temp = [0] * (sum(prime_lst)+1)
for i in xrange(3,len(temp),2):
if temp[i] == 0:
prime_set2.add(i)
for j in xrange(3*i,len(temp),2*i):
temp[j] = 1
lst = [1] + [0]*(sum(prime_lst))
print "Time Taken: ", time.time() - START
sumz = 0
for i in xrange(0,len(prime_lst)):
for j in xrange(sumz,-1,-1):
index = j + prime_lst[i]
lst[index] = (lst[j] + lst[index]) % MOD
sumz += prime_lst[i]
print "Time Taken: ", time.time() - START
import time
from primes import factor, get_primes
START = time.time()
SIZE = 100
primes = get_primes(SIZE)[::-1]
LIM = reduce(lambda x,y: x*y, primes)**.5
def prod(lst):
if lst == []:
return 1
return reduce(lambda x,y: x*y, lst)
valid_set = set([1])
for index in xrange(len(primes)):
prime = primes[index]
remainingProd = prod(primes[index+1:])
maxElem = max(valid_set)
print prime, len(valid_set), "Time Taken:", time.time() - START
valid_set.update( \
set(filter(lambda x: x < LIM and x * remainingProd > maxElem, \
[prime * val for val in valid_set])))
valid_set = set(filter( lambda x: x < LIM and x * remainingProd >= maxElem, valid_set))
print LIM - max(valid_set)
print "Time Taken:", time.time() - START
import time
from primes import get_primes
START = time.time()
SIZE = 10**5 * 25
primes = get_primes(SIZE * 40)
coords = [(primes[0], primes[0])]
print "Time Taken:", time.time() - START
for i in xrange(1, SIZE):
coords.append( (coords[-1][0] + primes[2*i] + primes[2*i-1], \
coords[-1][1] + primes[2*i] - primes[2*i-1]) \
)
totalCount = 1
maxDiff = 10
for currentPeakIndex in xrange(1, SIZE):
if currentPeakIndex % 10** 5 == 0:
print currentPeakIndex, time.time() - START
currentPeak = coords[currentPeakIndex]
peakCount = 0
viewAngle = 1
for prevPeakIndex in xrange(currentPeakIndex - 1, currentPeakIndex - min(currentPeakIndex, maxDiff * 2),-1):
prevPeak = coords[prevPeakIndex]
nextAngle = (1.0 * currentPeak[1] - prevPeak[1]) / (currentPeak[0] - prevPeak[0])
if nextAngle < viewAngle:
peakCount +=1
viewAngle = nextAngle
maxDiff = max(currentPeakIndex - prevPeakIndex, maxDiff)
totalCount += peakCount
"""
import primes
def primelength(a, b):
i = 0
while primes.is_prime(i*(i + a) + b):
i += 1
return i
#print primelength(1, 41) # should be 40
#print primelength(-79, 1601) # should be 80
best_pair = (-29, 251)
longest_length = 55
possible_b = primes.get_primes(1000, greater_than=best_pair[1] - 1)
print possible_b
for b in possible_b:
print "Trying ", b
for a in xrange(-1 * b + 2, 1000, 2):
length = primelength(a, b)
if length > longest_length:
longest_length = length
best_pair = (a, b)
print "longest_length: ", longest_length
print "best_pair: ", best_pair
print "longest_length: ", longest_length
print "best_pair: ", best_pair
import time
START = time.time()
from primes import factor, get_primes, primes
SIZE = 190
prime_list = get_primes(SIZE)
prod = reduce(lambda x,y: x*y, prime_list)
PROD_LIM = int(prod**.5)
vals = set([1])
maxVal = 0
for p in prime_list:
print p, maxVal, len(vals)
for val in list(vals):
if p * val > PROD_LIM:
vals.remove(val)
continue
if p * val > maxVal:
maxVal = p * val
if p**2 * val < PROD_LIM:
vals.add(p*val)
print len(vals), max(vals), maxVal
print "Time Taken:", time.time() - START
import time
from primes import get_primes, divisors, m_r
START = time.time()
SIZE = 10**6 * 5
LIM = 10**5
primes = get_primes(SIZE)
div308 = divisors(308)
results = []
for p in primes:
if len(results) > LIM: break
if not any([m_r(div * p + 1) for div in div308]):
results.append(p)
print results[LIM - 2] * 308, len(results)
for repetition in xrange(10):
resultSet = set(results)
for index, a in enumerate(results):
if a * results[0] > results[LIM]: break
for bIndex in xrange(index + 1):
b = results[bIndex]
p = a * b
if a * b > results[LIM]: break
if not any([m_r(div * p + 1) for div in div308]):
if len(filter(lambda x: x not in resultSet,
divisors(p)[1:-1])) == 0:
import time
from primes import get_prime_count, get_primes
SIZE = 10**12
START = time.time()
primes = get_primes(int(SIZE**.5) * 100)
primeLen = len(primes)
print "Time Taken:", time.time() - START
numPrimesLessThanN = [0] * (int(SIZE**.5) * 100)
primeIndex = 0
while primeIndex < len(primes) - 1:
for index in xrange(primes[primeIndex], primes[primeIndex + 1]):
numPrimesLessThanN[index] = primeIndex + 1
primeIndex += 1
numPrimesLessThanN[primes[-1]:] = [len(primes)
] * (len(numPrimesLessThanN) - primes[-1])
count = 0
# Part 1, p^7 < SIZE
count += get_prime_count(int(SIZE**(1 / 7.)))
print "Part 1 is:", count
print "Time Taken:", time.time() - START
START = time.time()
# Part 2, i^3*j < SIZE
i = 0
def right_truncatables():
primes = list(get_primes(10))
while primes:
primes = filter(is_prime, (10*p+d for p in primes for d in (1,3,7,9)))
for p in primes:
yield p
import time
from primes import get_primes, gcd, crt, lcm_list
START = time.time()
SIZE = 10**12
factor = {1 : [], 2: [2], 3: [3]}
answers = set([1,2])
possibleAns = set([1])
primes = get_primes(int(SIZE**.5))
def checkProperty(m, factors=None):
if not factors:
factors = factor[m]
for f in factors:
if (m + 3) % (f - 1) != 0:
return False
return True
compatCache = dict()
def compat_check(p1, p2):
if (p1,p2) in compatCache:
return compatCache[(p1,p2)]
gcd1 = gcd(p1-1, p2)
if gcd1 != 1:
if (p1-4) % gcd1 != 0:
compatCache[(p1,p2)] = False
return False
gcd2 = gcd(p2-1, p1)
if gcd2 != 1:
if (p2-4) % gcd2 != 0:
def solution():
N = 1000000
return len(filter(is_circular, get_primes(N)))
#NOTE TODO need to solve it
import time, math
from primes import get_primes, factor
START = time.time()
MAX_SIZE = 10**11
LIM = MAX_SIZE / (7*13*19*9)
prime_lst = get_primes(LIM)
prime_lst = sorted([9] + filter( (lambda x: x % 3 == 1), prime_lst))
other_nums = range(LIM)
for prime in prime_lst:
for i in xrange(prime, len(other_nums), prime):
other_nums[prime] = 0
def test(n):
return sum(filter(lambda x: x==1, [x**3 % n for x in xrange(n)]))
def getAnswer(currentProd, currentIndex, numLeft):
if numLeft == 0:
return currentProd * sum(other_nums[1:MAX_SIZE/currentProd + 1])
sumz = 0
for index in xrange(currentIndex, len(prime_lst)):
if currentProd * prime_lst[index]**numLeft > MAX_SIZE:
break
if currentIndex == 0:
print index
currentPrime = prime_lst[index]
import sys
from math import gcd
from fractions import Fraction
from primes import get_primes
pr = get_primes(10000000)
print('generated')
def factor(d):
q = d**0.5
if d in pr:
yield d
else:
for x in pr:
if x > q:
break
if d % x == 0:
yield x
def phi(d):
num, den = d, 1
for x in factor(d):
num *= x - 1
den *= x
return num // den
for x in range(1, 11):
print(phi(x))
import time
START = time.time()
from primes import factor, get_primes, primes
SIZE = 190
prime_list = get_primes(SIZE)
prod = reduce(lambda x, y: x * y, prime_list)
PROD_LIM = int(prod**.5)
vals = set([1])
maxVal = 0
for p in prime_list:
print p, maxVal, len(vals)
for val in list(vals):
if p * val > PROD_LIM:
vals.remove(val)
continue
if p * val > maxVal:
maxVal = p * val
if p**2 * val < PROD_LIM:
vals.add(p * val)
print len(vals), max(vals), maxVal
print "Time Taken:", time.time() - START
def substringdivisible(n): # n is a string or list of digits
substrings = (int(''.join(n[i+1:i+4])) for i in range(7))
divisors = primes.get_primes()
return all(s % d == 0 for s,d in zip(substrings,divisors))
"""
The number, 197, is called a circular prime because all rotations of the digits: 197, 971, and 719, are themselves prime.
There are thirteen such primes below 100: 2, 3, 5, 7, 11, 13, 17, 31, 37, 71, 73, 79, and 97.
How many circular primes are there below one million?
"""
import digits
import primes
from itertools import permutations
pbm = filter(lambda p : 0 not in digits.get_all(p), primes.get_primes(1000000))
pbm = filter(lambda p : 2 not in digits.get_all(p), pbm)
pbm = filter(lambda p : 4 not in digits.get_all(p), pbm)
pbm = filter(lambda p : 5 not in digits.get_all(p), pbm)
pbm = filter(lambda p : 6 not in digits.get_all(p), pbm)
pbm = filter(lambda p : 8 not in digits.get_all(p), pbm)
cpms = set([2, 5])
ncpms = set([])
def rotations(l):
l2 = l * 1
for i in xrange(len(l2)):
l2 = l2[1:] + [l2[0]]
yield l2
for prime in pbm:
from primes import get_primes
from compare import compare
from time import time
PS = get_primes()
def quadratic_formula(a, b):
def inner(x):
return abs(x ** 2 + a * x + b)
return inner
def is_prime(n):
return n in PS
def solution(N):
imax = -N
jmax = -N
res_max = 0
for i in range(-1*N, N+1):
t0 = time()
for j in range(-1*N, N+1):
x = 0
qf = quadratic_formula(i, j)
res = 0
while 1:
if is_prime(qf(x)):
res += 1
x += 1
else:
if res > res_max:
imax = i
def test_one_hundred_one(self):
generator = get_primes(101)
self.assertEqual(generator.next(), 101)
self.assertEqual(generator.next(), 103)
self.assertEqual(generator.next(), 107)
import time, math
from primes import get_primes, factor_given_pfactor, pfactor_gen, get_divisors_given_pfactor
START = time.time()
SIZE = 10**8
primesList = get_primes(SIZE)
pfactorList = pfactor_gen(SIZE)
primeSet = set(primesList)
def factor(n):
return factor_given_pfactor(n, pfactorList)
def divisors(n):
return get_divisors_given_pfactor(n, pfactorList)
answers = set()
for p in primesList:
print p
divs = divisors(p+1)
for div1 in divs:
for div2 in divs:
if div1 <= div2:
continue
top = ((p+1) * div1) / div2 - 1
bottom = ((p+1) * div2) / div1 - 1
if top > SIZE:
continue
if top in primeSet and bottom in primeSet:
answers.add((top, p, bottom))
print sum([x[0] +x[1] + x[2] for x in answers])
#NOTE TODO need to solve it
import time, math
from primes import crt, get_primes
START = time.time()
SIZE = 3 * 10**5
prime_num = get_primes(SIZE)
prime_set = set(prime_num)
prime_set.discard(2)
prime_set.discard(3)
def factor(number):
factors = []
for prime in sorted(prime_set):
if number % prime == 0:
factors.append(prime)
number /= prime
if number == 1:
break
# i really don't care about larger factors
return factors
print "There are:", len(prime_num), "primes"
product = 2
number = 1
prime_factors = set([])
import time, math
from primes import get_primes, factor_given_pfactor, pfactor_gen, get_divisors_given_pfactor
START = time.time()
SIZE = 10**8
primesList = get_primes(SIZE)
pfactorList = pfactor_gen(SIZE)
primeSet = set(primesList)
def factor(n):
return factor_given_pfactor(n, pfactorList)
def divisors(n):
return get_divisors_given_pfactor(n, pfactorList)
answers = set()
for p in primesList:
print p
divs = divisors(p + 1)
for div1 in divs:
for div2 in divs:
if div1 <= div2:
continue
top = ((p + 1) * div1) / div2 - 1
bottom = ((p + 1) * div2) / div1 - 1
if top > SIZE:
continue
if top in primeSet and bottom in primeSet:
#NOTE TODO need to solve it
import time, math
from primes import get_primes, factor
START = time.time()
MAX_SIZE = 10**11
LIM = MAX_SIZE / (7 * 13 * 19 * 9)
prime_lst = get_primes(LIM)
prime_lst = sorted([9] + filter((lambda x: x % 3 == 1), prime_lst))
other_nums = range(LIM)
for prime in prime_lst:
for i in xrange(prime, len(other_nums), prime):
other_nums[prime] = 0
def test(n):
return sum(filter(lambda x: x == 1, [x**3 % n for x in xrange(n)]))
def getAnswer(currentProd, currentIndex, numLeft):
if numLeft == 0:
return currentProd * sum(other_nums[1:MAX_SIZE / currentProd + 1])
sumz = 0
for index in xrange(currentIndex, len(prime_lst)):
if currentProd * prime_lst[index]**numLeft > MAX_SIZE:
break
if currentIndex == 0:
print index
def test_one(self):
generator = get_primes(1)
self.assertEqual(generator.next(), 2)
self.assertEqual(generator.next(), 3)
self.assertEqual(generator.next(), 5)
#!/usr/bin/python
from primes import get_primes
# pretty simple, just determine for each prime, p, the set of primes
# {q: q >= p && p*q < Nmax}. Each of these items contributes a single
# count to the result.
NMAX = 100000000
primes = get_primes(NMAX/2)
result = 0
lastptr = -1
for (ip, p) in enumerate(primes):
q = primes[lastptr]
while p*q >= NMAX:
lastptr -= 1
q = primes[lastptr]
if q < p:
break
num_items = len(primes) + 1 + lastptr - ip
result += num_items
print(result)
from primes import get_primes
from time import time
print(get_primes(10))
start = time()
n = 1000000
prime_numbers = get_primes(n)
print(f"{len(prime_numbers)} total prime numbers under {n}")
print(f"{prime_numbers[10002]} is the 10001-st prime number")
print(f"Total execution time: {round(time()-start, 2)}")
