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)}")