Example #1
0
def smallest_multiple_fastest(n):
    prod = 1
    for prime in generate_primes(int(n**0.5)):
        prod *= prime**int(log(n, prime))
    for prime in generate_primes(int(1 + n**0.5), n):
        prod *= prime
    return prod
Example #2
0
File: e35.py Project: yuda110/euler
def get_circular_prime(range_to):
    count = 1    #2!
    prime_list = primesieve.generate_primes(range_to)      #[2, 3, 5, 7, 11, 13, 17, 19....]
    for prime in prime_list:
        if is_circular_prime(prime) == True :
            count += 1
    return count
Example #3
0
def run(n):
    pl = ps.generate_primes(n)
    ret = 0
    for q in pl:
        if is_unique(q):
            ret += q
    return ret
Example #4
0
def get_circular_prime(range_to):
    count = 1  #2!
    prime_list = primesieve.generate_primes(
        range_to)  #[2, 3, 5, 7, 11, 13, 17, 19....]
    for prime in prime_list:
        if is_circular_prime(prime) == True:
            count += 1
    return count
Example #5
0
def get_biggest_decimal_pandigital(n):
    max_pan = 0
    permu_obj = itertools.permutations(range(1, n + 1))
    for pan in permu_obj:
        each_pan = int(''.join(map(str, pan)))
        if len(generate_primes(each_pan, each_pan)) > 0 and each_pan > max_pan:
            max_pan = each_pan
    return max_pan
Example #6
0
File: e41.py Project: yuda110/euler
def get_biggest_decimal_pandigital(n):
    max_pan = 0
    permu_obj = itertools.permutations(range(1, n+1))
    for pan in permu_obj:
        each_pan = int(''.join(map(str,pan)))
        if len(generate_primes(each_pan, each_pan)) > 0  and each_pan > max_pan:
            max_pan = each_pan
    return max_pan
Example #7
0
def getPrimesOfMagnitudePS(mag):

    """
    Get all primes of mag orders of magnitude using PrimeSieve
    """
    lwr = 10**(mag-1)
    upr = 10**mag

    return ps.generate_primes(lwr,upr)
Example #8
0
def list_generate_primes_array(a, b):
    logger.info("starting generating primes from {} to {}".format(a, b))
    logger.info("\tusing primesieve list prime generation")
    a = primesieve.generate_primes(a, b)
    logger.info("\tprimes generated")
    a = np.array(a, dtype=np.uint64)
    logger.info("\toutput array created")
    logger.info("done generating primes")
    return a
Example #9
0
def get_still_prime_sum(range_from, range_to):
    prime_list = primesieve.generate_primes(range_from, range_to)
    result_cnt = 0
    result_sum = 0
    for prime in prime_list:
        if is_still_prime(prime):
            result_sum += prime
            result_cnt += 1
            if result_cnt == 11 :
                break
    return result_sum
Example #10
0
def get_still_prime_sum(range_from, range_to):
    prime_list = primesieve.generate_primes(range_from, range_to)
    result_cnt = 0
    result_sum = 0
    for prime in prime_list:
        if is_still_prime(prime):
            result_sum += prime
            result_cnt += 1
            if result_cnt == 11:
                break
    return result_sum
Example #11
0
def search_cumulative_primes(max_range):
    """ Search for the first cumulative """
    log.info("Start looking for cumulative primes: %d" % max_range)
    res = None
    num_of_primes = 0

    primes = primesieve.generate_primes(max_range)
    primesum = generate_primes_sum(primes)

    # check for every cumulative sum, every possible sum of primes
    for i in range(len(primesum)):
        j = i - (num_of_primes + 1)

        while j > 0:
            prime_candidate = primesum[i] - primesum[j]
            if prime_candidate > max_range:
                break
            if binary_search(primes, prime_candidate):
                num_of_primes = i - j
                res = prime_candidate
            j = j - 1

    return res
Example #12
0
import primesieve
from allfunction import *


def shengcheng(n):
    if len(str(n)) == 1:
        return [n]


count = 0
a = primesieve.generate_primes(1000000)
isprimelist = [False for _ in range(1000001)]
for i in a:
    isprimelist[i] = True

for p in a:

    #b=num2list(p)
    l = len(str(p))
    h = 10**(l - 1)
    flag = True
    t = p
    for i in range(1, l):
        t = t // 10 + t % 10 * h
        if not isprimelist[t]:
            flag = False
            break
    if flag:
        print(p)
        count += 1
    '''
Example #13
0
6   1,5                 2       3           2 3 4
7   1,2,3,4,5,6         6       1.1666...   
8   1,3,5,7             4       2           2   4   6
9   1,2,4,5,7,8         6       1.5           3     6
10  1,3,7,9             4       2.5         2   4 5 6 8

It can be seen that n=6 produces a maximum n/φ(n) for n ≤ 10.

Find the value of n ≤ 1,000,000 for which n/φ(n) is a maximum.
'''

from pprint import pprint
from primesieve import generate_primes

limit = 1000000
primes = generate_primes(limit)

inverses = { key: set() for key in range(2, limit+1) }

def check_prime(n):
    return len(generate_primes(n, n))

for p in primes:
    #print('\nADDING PRIME', p, '\n')
    #if check_prime(p):
        for n in range(p*2, limit+1, p):
            #print('adding', p, 'to n', n)
            for inverse in range(p, n-1, p):
                #print(inverse)
                inverses[n].add(inverse)
Example #14
0
# -*- coding: utf-8 -*-
"""
Created on Sun May 14 00:59:16 2017

@author: Steven
"""

import timeit
from primesieve import generate_primes
start = timeit.default_timer()

print(sum(generate_primes(2000000)))

stop = timeit.default_timer()
print(stop - start, "seconds")
Example #15
0
def test_generate_primes():
    assert primesieve.generate_primes(10) == [2, 3, 5, 7]
Example #16
0
Find the sum of all the primes below two million.
'''

if __name__ == '__main__':

    print len([
        2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,
        71, 73, 79, 83, 89, 97, 101, 103
    ])
    print list(primesbelow(108))

    # print generate_primes(2*10**6)
    import timeit
    limit = 2 * 10**6
    print sum(primesbelow(limit))
    print sum(generate_primes(limit))

    times = 10**4
    t1 = timeit.timeit("primesbelow(2*10**6)",
                       setup="from __main__ import primesbelow",
                       number=times) / float(times)
    t2 = timeit.timeit("generate_primes(2*10**6)",
                       setup="from __main__ import generate_primes",
                       number=times) / float(times)

    print "primesbelow", t1 * 1000, 'ms'
    print "generate_primes", t2 * 1000, 'ms'

    print "My solution used: ", 1000 * t1, "ms"
    print "The C++ solution used:  ", 1000 * t2, "ms"
Example #17
0
Prime pair sets
Problem 60

The primes 3, 7, 109, and 673, are quite remarkable. By taking any two primes 
and concatenating them in any order the result will always be prime. For 
example, taking 7 and 109, both 7109 and 1097 are prime. The sum of these four 
primes, 792, represents the lowest sum for a set of four primes with this 
property.

Find the lowest sum for a set of five primes for which any two primes 
concatenate to produce another prime.
'''

from primesieve import generate_primes

full_primes = generate_primes(100000000)
p_set = set(full_primes)

primes = generate_primes(674, 10000000)
four = [3, 7, 109, 673]

for n in primes:
    print(n)
    okay = True
    for m in four:
        str_n = str(n)
        str_m = str(m)
        a = int(str_n + str_m)
        b = int(str_m + str_n)
        if not ((a in p_set) and (b in p_set)):
            print(n, m, 'is not okay!!!')
Example #18
0
def smallest_multiple_fast(n):
    prod = 1
    for prime in generate_primes(n):
        prod *= prime**int(log(n, prime))
    return prod
Example #19
0

n = 1
i = 1
length = 1
solved = False
corners = [1]
prime_tally = 0
total_tally = 1

while not solved:
    for j in range(4):
        corner = n + (2 * i)
        #print(corner)
        corners.append(corner)
        if generate_primes(corner, corner):
            #if corner in primes:
            prime_tally += 1
        total_tally += 1
        n += (2 * i)
    length = (2 * i) + 1
    ratio = prime_tally / total_tally
    #print('Length:', length)
    #print(prime_tally, '/', total_tally, '=', ratio, '\n')
    if ratio < 0.1:
        solved = True
    i += 1

print('Length:', length)
print(prime_tally, '/', total_tally, '=', ratio, '\n')
'''
def check(n):
    if not n in d:
        test = generate_primes(n, n)
        d[n] = len(test)
    return d[n]
Example #21
0
primes = []
bin_mask = 1
limit = 1
quota = 8

def find_first(s):
    prime_set = set(primes)
    for n in range(10):
        to_check = s.replace('*', str(n))
        if int(to_check) in prime_set:
            print("It's", to_check)
            exit()

while True:
    print('Checking up to', limit*10)
    primes = generate_primes(limit, limit*10)
    for i in range(1, bin_mask*2-1):
        hits = {}
        mask = str("{0:b}".format(i)).zfill(len(str(limit)))
        for p in primes:
            s = ''
            digit = None
            for i, d in enumerate(str(p)):
                fail = False
                if mask[i] == '1':
                    if d == digit or digit == None:
                        s += '*'
                        digit = d
                    else:
                        fail = True
                        break
Example #22
0
def prime_check(n):
    if not n in primes_d:
        test = generate_primes(n, n)
        primes_d[n] = len(test)
    return primes_d[n]
def test_generate_primes():
    assert primesieve.generate_primes(10) == [2,3,5,7]
Example #24
0
def check(n):
    generate_primes(n, n)
    return d[n]
Example #25
0
def check_prime(n):
    return len(generate_primes(n, n))
Example #26
0
    reader = csv.reader(recipe)
    keys = []
    for row in reader:
        type = row[0]
        if type in ['file']:
            _, start, stop, path = row
            start = int(start or 0)
            stop = int(stop or -1)
            if stop < 0:
                stop = None
            key = FileSource(path, start, stop)

        if type in ['www']:
            _, start, stop, url = row
            start = int(start or 0)
            stop = int(stop or -1)
            if stop < 0:
                stop = None
            key = WebSource(url, start, stop)

        if type in ['passphrase']:
            _, phrase = row
            key = passphrase(phrase)

        keys.append(key)

    return (keys)


primes = filter(lambda x: x % 4 == 3, primesieve.generate_primes(10**6))
Example #27
0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Feb 27 08:47:05 2017

@author: Pranavtadepalli
"""
import primesieve
primes = primesieve.generate_primes(2000000)
print(sum(primes))
def test_generate_primes():
    assert primesieve.generate_primes(10) == [2,3,5,7]
    assert primesieve.generate_primes(10, 20) == [11,13,17,19]