Cara tercepat untuk mendaftar semua bilangan prima di bawah N


357

Ini adalah algoritma terbaik yang bisa saya kemukakan.

def get_primes(n):
    numbers = set(range(n, 1, -1))
    primes = []
    while numbers:
        p = numbers.pop()
        primes.append(p)
        numbers.difference_update(set(range(p*2, n+1, p)))
    return primes

>>> timeit.Timer(stmt='get_primes.get_primes(1000000)', setup='import   get_primes').timeit(1)
1.1499958793645562

Bisakah itu dibuat lebih cepat?

Kode ini memiliki kekurangan: Karena numbersmerupakan kumpulan yang tidak berurutan, tidak ada jaminan yang numbers.pop()akan menghapus angka terendah dari kumpulan tersebut. Namun demikian, ini berfungsi (setidaknya bagi saya) untuk beberapa nomor input:

>>> sum(get_primes(2000000))
142913828922L
#That's the correct sum of all numbers below 2 million
>>> 529 in get_primes(1000)
False
>>> 529 in get_primes(530)
True

Cuplikan kode yang dipermasalahkan jauh lebih cepat jika angka dinyatakan seperti angka = set (rentang (n, 2, -2)). Tapi tidak bisa mengalahkan sundaram3. Terima kasih untuk pertanyaannya.
Shekhar

3
Akan lebih baik jika ada versi Python 3 fungsi dalam jawaban.
Michael Foukarakis

Tentunya ada perpustakaan untuk melakukan ini sehingga kita tidak perlu menggulung sendiri> xkcd yang dijanjikan Python semudah import antigravity. Apakah tidak ada yang seperti require 'prime'; Prime.take(10)(Ruby)?
Kolonel Panic

2
@ColonelPanic Seperti yang terjadi, saya memperbarui github.com/jaredks/pyprimesieve untuk Py3 dan ditambahkan ke PyPi. Ini tentu saja lebih cepat daripada ini tetapi bukan urutan besarnya - lebih seperti ~ 5x lebih cepat dari versi numpy terbaik.
Jared

3
@ColonelPanic: Saya pikir mengedit jawaban lama untuk mencatat bahwa mereka sudah tua sudah tepat, karena itu menjadikannya sumber daya yang lebih berguna. Jika jawaban "diterima" bukan lagi yang terbaik, mungkin edit catatan ke pertanyaan dengan pembaruan 2015 untuk mengarahkan orang ke metode terbaik saat ini.
Peter Cordes

Jawaban:


366

Peringatan: timeit hasil dapat bervariasi karena perbedaan perangkat keras atau versi Python.

Di bawah ini adalah skrip yang membandingkan sejumlah implementasi:

Banyak terima kasih kepada stephan karena telah membawa sieve_wheel_30 menjadi perhatian saya. Penghargaan diberikan kepada Robert William Hanks untuk primesfrom2to, primesfrom3to, rwh_primes, rwh_primes1, dan rwh_primes2.

Dari metode Python biasa diuji, dengan psyco , untuk n = 1000000, rwh_primes1 adalah yang tercepat diuji.

+---------------------+-------+
| Method              | ms    |
+---------------------+-------+
| rwh_primes1         | 43.0  |
| sieveOfAtkin        | 46.4  |
| rwh_primes          | 57.4  |
| sieve_wheel_30      | 63.0  |
| rwh_primes2         | 67.8  |    
| sieveOfEratosthenes | 147.0 |
| ambi_sieve_plain    | 152.0 |
| sundaram3           | 194.0 |
+---------------------+-------+

Dari metode Python biasa yang diuji, tanpa psyco , untuk n = 1000000, rwh_primes2 adalah yang tercepat.

+---------------------+-------+
| Method              | ms    |
+---------------------+-------+
| rwh_primes2         | 68.1  |
| rwh_primes1         | 93.7  |
| rwh_primes          | 94.6  |
| sieve_wheel_30      | 97.4  |
| sieveOfEratosthenes | 178.0 |
| ambi_sieve_plain    | 286.0 |
| sieveOfAtkin        | 314.0 |
| sundaram3           | 416.0 |
+---------------------+-------+

Dari semua metode yang diuji, memungkinkan numpy , untuk n = 1000000, primesfrom2to adalah yang tercepat diuji.

+---------------------+-------+
| Method              | ms    |
+---------------------+-------+
| primesfrom2to       | 15.9  |
| primesfrom3to       | 18.4  |
| ambi_sieve          | 29.3  |
+---------------------+-------+

Pengaturan waktu diukur menggunakan perintah:

python -mtimeit -s"import primes" "primes.{method}(1000000)"

dengan {method}diganti oleh masing-masing nama metode.

primes.py:

#!/usr/bin/env python
import psyco; psyco.full()
from math import sqrt, ceil
import numpy as np

def rwh_primes(n):
    # /programming/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    """ Returns  a list of primes < n """
    sieve = [True] * n
    for i in xrange(3,int(n**0.5)+1,2):
        if sieve[i]:
            sieve[i*i::2*i]=[False]*((n-i*i-1)/(2*i)+1)
    return [2] + [i for i in xrange(3,n,2) if sieve[i]]

def rwh_primes1(n):
    # /programming/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    """ Returns  a list of primes < n """
    sieve = [True] * (n/2)
    for i in xrange(3,int(n**0.5)+1,2):
        if sieve[i/2]:
            sieve[i*i/2::i] = [False] * ((n-i*i-1)/(2*i)+1)
    return [2] + [2*i+1 for i in xrange(1,n/2) if sieve[i]]

def rwh_primes2(n):
    # /programming/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    """ Input n>=6, Returns a list of primes, 2 <= p < n """
    correction = (n%6>1)
    n = {0:n,1:n-1,2:n+4,3:n+3,4:n+2,5:n+1}[n%6]
    sieve = [True] * (n/3)
    sieve[0] = False
    for i in xrange(int(n**0.5)/3+1):
      if sieve[i]:
        k=3*i+1|1
        sieve[      ((k*k)/3)      ::2*k]=[False]*((n/6-(k*k)/6-1)/k+1)
        sieve[(k*k+4*k-2*k*(i&1))/3::2*k]=[False]*((n/6-(k*k+4*k-2*k*(i&1))/6-1)/k+1)
    return [2,3] + [3*i+1|1 for i in xrange(1,n/3-correction) if sieve[i]]

def sieve_wheel_30(N):
    # http://zerovolt.com/?p=88
    ''' Returns a list of primes <= N using wheel criterion 2*3*5 = 30

Copyright 2009 by zerovolt.com
This code is free for non-commercial purposes, in which case you can just leave this comment as a credit for my work.
If you need this code for commercial purposes, please contact me by sending an email to: info [at] zerovolt [dot] com.'''
    __smallp = ( 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, 107, 109, 113, 127, 131, 137, 139,
    149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227,
    229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311,
    313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401,
    409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491,
    499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599,
    601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683,
    691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797,
    809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887,
    907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997)

    wheel = (2, 3, 5)
    const = 30
    if N < 2:
        return []
    if N <= const:
        pos = 0
        while __smallp[pos] <= N:
            pos += 1
        return list(__smallp[:pos])
    # make the offsets list
    offsets = (7, 11, 13, 17, 19, 23, 29, 1)
    # prepare the list
    p = [2, 3, 5]
    dim = 2 + N // const
    tk1  = [True] * dim
    tk7  = [True] * dim
    tk11 = [True] * dim
    tk13 = [True] * dim
    tk17 = [True] * dim
    tk19 = [True] * dim
    tk23 = [True] * dim
    tk29 = [True] * dim
    tk1[0] = False
    # help dictionary d
    # d[a , b] = c  ==> if I want to find the smallest useful multiple of (30*pos)+a
    # on tkc, then I need the index given by the product of [(30*pos)+a][(30*pos)+b]
    # in general. If b < a, I need [(30*pos)+a][(30*(pos+1))+b]
    d = {}
    for x in offsets:
        for y in offsets:
            res = (x*y) % const
            if res in offsets:
                d[(x, res)] = y
    # another help dictionary: gives tkx calling tmptk[x]
    tmptk = {1:tk1, 7:tk7, 11:tk11, 13:tk13, 17:tk17, 19:tk19, 23:tk23, 29:tk29}
    pos, prime, lastadded, stop = 0, 0, 0, int(ceil(sqrt(N)))
    # inner functions definition
    def del_mult(tk, start, step):
        for k in xrange(start, len(tk), step):
            tk[k] = False
    # end of inner functions definition
    cpos = const * pos
    while prime < stop:
        # 30k + 7
        if tk7[pos]:
            prime = cpos + 7
            p.append(prime)
            lastadded = 7
            for off in offsets:
                tmp = d[(7, off)]
                start = (pos + prime) if off == 7 else (prime * (const * (pos + 1 if tmp < 7 else 0) + tmp) )//const
                del_mult(tmptk[off], start, prime)
        # 30k + 11
        if tk11[pos]:
            prime = cpos + 11
            p.append(prime)
            lastadded = 11
            for off in offsets:
                tmp = d[(11, off)]
                start = (pos + prime) if off == 11 else (prime * (const * (pos + 1 if tmp < 11 else 0) + tmp) )//const
                del_mult(tmptk[off], start, prime)
        # 30k + 13
        if tk13[pos]:
            prime = cpos + 13
            p.append(prime)
            lastadded = 13
            for off in offsets:
                tmp = d[(13, off)]
                start = (pos + prime) if off == 13 else (prime * (const * (pos + 1 if tmp < 13 else 0) + tmp) )//const
                del_mult(tmptk[off], start, prime)
        # 30k + 17
        if tk17[pos]:
            prime = cpos + 17
            p.append(prime)
            lastadded = 17
            for off in offsets:
                tmp = d[(17, off)]
                start = (pos + prime) if off == 17 else (prime * (const * (pos + 1 if tmp < 17 else 0) + tmp) )//const
                del_mult(tmptk[off], start, prime)
        # 30k + 19
        if tk19[pos]:
            prime = cpos + 19
            p.append(prime)
            lastadded = 19
            for off in offsets:
                tmp = d[(19, off)]
                start = (pos + prime) if off == 19 else (prime * (const * (pos + 1 if tmp < 19 else 0) + tmp) )//const
                del_mult(tmptk[off], start, prime)
        # 30k + 23
        if tk23[pos]:
            prime = cpos + 23
            p.append(prime)
            lastadded = 23
            for off in offsets:
                tmp = d[(23, off)]
                start = (pos + prime) if off == 23 else (prime * (const * (pos + 1 if tmp < 23 else 0) + tmp) )//const
                del_mult(tmptk[off], start, prime)
        # 30k + 29
        if tk29[pos]:
            prime = cpos + 29
            p.append(prime)
            lastadded = 29
            for off in offsets:
                tmp = d[(29, off)]
                start = (pos + prime) if off == 29 else (prime * (const * (pos + 1 if tmp < 29 else 0) + tmp) )//const
                del_mult(tmptk[off], start, prime)
        # now we go back to top tk1, so we need to increase pos by 1
        pos += 1
        cpos = const * pos
        # 30k + 1
        if tk1[pos]:
            prime = cpos + 1
            p.append(prime)
            lastadded = 1
            for off in offsets:
                tmp = d[(1, off)]
                start = (pos + prime) if off == 1 else (prime * (const * pos + tmp) )//const
                del_mult(tmptk[off], start, prime)
    # time to add remaining primes
    # if lastadded == 1, remove last element and start adding them from tk1
    # this way we don't need an "if" within the last while
    if lastadded == 1:
        p.pop()
    # now complete for every other possible prime
    while pos < len(tk1):
        cpos = const * pos
        if tk1[pos]: p.append(cpos + 1)
        if tk7[pos]: p.append(cpos + 7)
        if tk11[pos]: p.append(cpos + 11)
        if tk13[pos]: p.append(cpos + 13)
        if tk17[pos]: p.append(cpos + 17)
        if tk19[pos]: p.append(cpos + 19)
        if tk23[pos]: p.append(cpos + 23)
        if tk29[pos]: p.append(cpos + 29)
        pos += 1
    # remove exceeding if present
    pos = len(p) - 1
    while p[pos] > N:
        pos -= 1
    if pos < len(p) - 1:
        del p[pos+1:]
    # return p list
    return p

def sieveOfEratosthenes(n):
    """sieveOfEratosthenes(n): return the list of the primes < n."""
    # Code from: <dickinsm@gmail.com>, Nov 30 2006
    # http://groups.google.com/group/comp.lang.python/msg/f1f10ced88c68c2d
    if n <= 2:
        return []
    sieve = range(3, n, 2)
    top = len(sieve)
    for si in sieve:
        if si:
            bottom = (si*si - 3) // 2
            if bottom >= top:
                break
            sieve[bottom::si] = [0] * -((bottom - top) // si)
    return [2] + [el for el in sieve if el]

def sieveOfAtkin(end):
    """sieveOfAtkin(end): return a list of all the prime numbers <end
    using the Sieve of Atkin."""
    # Code by Steve Krenzel, <Sgk284@gmail.com>, improved
    # Code: https://web.archive.org/web/20080324064651/http://krenzel.info/?p=83
    # Info: http://en.wikipedia.org/wiki/Sieve_of_Atkin
    assert end > 0
    lng = ((end-1) // 2)
    sieve = [False] * (lng + 1)

    x_max, x2, xd = int(sqrt((end-1)/4.0)), 0, 4
    for xd in xrange(4, 8*x_max + 2, 8):
        x2 += xd
        y_max = int(sqrt(end-x2))
        n, n_diff = x2 + y_max*y_max, (y_max << 1) - 1
        if not (n & 1):
            n -= n_diff
            n_diff -= 2
        for d in xrange((n_diff - 1) << 1, -1, -8):
            m = n % 12
            if m == 1 or m == 5:
                m = n >> 1
                sieve[m] = not sieve[m]
            n -= d

    x_max, x2, xd = int(sqrt((end-1) / 3.0)), 0, 3
    for xd in xrange(3, 6 * x_max + 2, 6):
        x2 += xd
        y_max = int(sqrt(end-x2))
        n, n_diff = x2 + y_max*y_max, (y_max << 1) - 1
        if not(n & 1):
            n -= n_diff
            n_diff -= 2
        for d in xrange((n_diff - 1) << 1, -1, -8):
            if n % 12 == 7:
                m = n >> 1
                sieve[m] = not sieve[m]
            n -= d

    x_max, y_min, x2, xd = int((2 + sqrt(4-8*(1-end)))/4), -1, 0, 3
    for x in xrange(1, x_max + 1):
        x2 += xd
        xd += 6
        if x2 >= end: y_min = (((int(ceil(sqrt(x2 - end))) - 1) << 1) - 2) << 1
        n, n_diff = ((x*x + x) << 1) - 1, (((x-1) << 1) - 2) << 1
        for d in xrange(n_diff, y_min, -8):
            if n % 12 == 11:
                m = n >> 1
                sieve[m] = not sieve[m]
            n += d

    primes = [2, 3]
    if end <= 3:
        return primes[:max(0,end-2)]

    for n in xrange(5 >> 1, (int(sqrt(end))+1) >> 1):
        if sieve[n]:
            primes.append((n << 1) + 1)
            aux = (n << 1) + 1
            aux *= aux
            for k in xrange(aux, end, 2 * aux):
                sieve[k >> 1] = False

    s  = int(sqrt(end)) + 1
    if s  % 2 == 0:
        s += 1
    primes.extend([i for i in xrange(s, end, 2) if sieve[i >> 1]])

    return primes

def ambi_sieve_plain(n):
    s = range(3, n, 2)
    for m in xrange(3, int(n**0.5)+1, 2): 
        if s[(m-3)/2]: 
            for t in xrange((m*m-3)/2,(n>>1)-1,m):
                s[t]=0
    return [2]+[t for t in s if t>0]

def sundaram3(max_n):
    # /programming/2068372/fastest-way-to-list-all-primes-below-n-in-python/2073279#2073279
    numbers = range(3, max_n+1, 2)
    half = (max_n)//2
    initial = 4

    for step in xrange(3, max_n+1, 2):
        for i in xrange(initial, half, step):
            numbers[i-1] = 0
        initial += 2*(step+1)

        if initial > half:
            return [2] + filter(None, numbers)

################################################################################
# Using Numpy:
def ambi_sieve(n):
    # http://tommih.blogspot.com/2009/04/fast-prime-number-generator.html
    s = np.arange(3, n, 2)
    for m in xrange(3, int(n ** 0.5)+1, 2): 
        if s[(m-3)/2]: 
            s[(m*m-3)/2::m]=0
    return np.r_[2, s[s>0]]

def primesfrom3to(n):
    # /programming/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    """ Returns a array of primes, p < n """
    assert n>=2
    sieve = np.ones(n/2, dtype=np.bool)
    for i in xrange(3,int(n**0.5)+1,2):
        if sieve[i/2]:
            sieve[i*i/2::i] = False
    return np.r_[2, 2*np.nonzero(sieve)[0][1::]+1]    

def primesfrom2to(n):
    # /programming/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    """ Input n>=6, Returns a array of primes, 2 <= p < n """
    sieve = np.ones(n/3 + (n%6==2), dtype=np.bool)
    sieve[0] = False
    for i in xrange(int(n**0.5)/3+1):
        if sieve[i]:
            k=3*i+1|1
            sieve[      ((k*k)/3)      ::2*k] = False
            sieve[(k*k+4*k-2*k*(i&1))/3::2*k] = False
    return np.r_[2,3,((3*np.nonzero(sieve)[0]+1)|1)]

if __name__=='__main__':
    import itertools
    import sys

    def test(f1,f2,num):
        print('Testing {f1} and {f2} return same results'.format(
            f1=f1.func_name,
            f2=f2.func_name))
        if not all([a==b for a,b in itertools.izip_longest(f1(num),f2(num))]):
            sys.exit("Error: %s(%s) != %s(%s)"%(f1.func_name,num,f2.func_name,num))

    n=1000000
    test(sieveOfAtkin,sieveOfEratosthenes,n)
    test(sieveOfAtkin,ambi_sieve,n)
    test(sieveOfAtkin,ambi_sieve_plain,n) 
    test(sieveOfAtkin,sundaram3,n)
    test(sieveOfAtkin,sieve_wheel_30,n)
    test(sieveOfAtkin,primesfrom3to,n)
    test(sieveOfAtkin,primesfrom2to,n)
    test(sieveOfAtkin,rwh_primes,n)
    test(sieveOfAtkin,rwh_primes1,n)         
    test(sieveOfAtkin,rwh_primes2,n)

Menjalankan tes skrip yang semua implementasi memberikan hasil yang sama.


4
Jika Anda tertarik pada kode non-murni-Python, maka Anda harus memeriksa gmpy- ia memiliki dukungan yang cukup bagus untuk bilangan prima, melalui next_primemetode mpzjenisnya.
Alex Martelli

1
Jika Anda menggunakan pypy, tolok ukur ini (yang psyco) tampaknya cukup baik. Cukup mengejutkan, saya menemukan sieveOfEratosthenes dan ambi_sieve_plain menjadi yang tercepat dengan pypy. Inilah yang saya temukan untuk yang non-numpy, gist.github.com/5bf466bb1ee9e5726a52
Ehsan Kia

1
Jika seseorang bertanya-tanya bagaimana fungsi di sini tarif terhadap PG7.8 dari Wikibooks untuk python murni tanpa psyco atau pypy: for n = 1000000: PG7.8: 4.93 s per loop; rwh_primes1: 69 ms per loop; rwh_primes2: 57,1 ms per loop
gaborous

8
Bisakah Anda memperbarui ini dengan PyPy, sekarang psyco sudah mati dan PyPy telah menggantikannya?
noɥʇʎԀʎzɐɹƆ

3
Akan lebih bagus jika fungsi dan timing ini dapat diperbarui untuk python3.
cs95

135

Kode Python murni yang lebih cepat & lebih bijaksana:

def primes(n):
    """ Returns  a list of primes < n """
    sieve = [True] * n
    for i in range(3,int(n**0.5)+1,2):
        if sieve[i]:
            sieve[i*i::2*i]=[False]*((n-i*i-1)//(2*i)+1)
    return [2] + [i for i in range(3,n,2) if sieve[i]]

atau mulai dengan setengah saringan

def primes1(n):
    """ Returns  a list of primes < n """
    sieve = [True] * (n//2)
    for i in range(3,int(n**0.5)+1,2):
        if sieve[i//2]:
            sieve[i*i//2::i] = [False] * ((n-i*i-1)//(2*i)+1)
    return [2] + [2*i+1 for i in range(1,n//2) if sieve[i]]

Kode numpy lebih cepat & lebih bijaksana untuk memori:

import numpy
def primesfrom3to(n):
    """ Returns a array of primes, 3 <= p < n """
    sieve = numpy.ones(n//2, dtype=numpy.bool)
    for i in range(3,int(n**0.5)+1,2):
        if sieve[i//2]:
            sieve[i*i//2::i] = False
    return 2*numpy.nonzero(sieve)[0][1::]+1

variasi yang lebih cepat dimulai dengan sepertiga ayakan:

import numpy
def primesfrom2to(n):
    """ Input n>=6, Returns a array of primes, 2 <= p < n """
    sieve = numpy.ones(n//3 + (n%6==2), dtype=numpy.bool)
    for i in range(1,int(n**0.5)//3+1):
        if sieve[i]:
            k=3*i+1|1
            sieve[       k*k//3     ::2*k] = False
            sieve[k*(k-2*(i&1)+4)//3::2*k] = False
    return numpy.r_[2,3,((3*numpy.nonzero(sieve)[0][1:]+1)|1)]

Versi python murni (sulit-kode) dari kode di atas adalah:

def primes2(n):
    """ Input n>=6, Returns a list of primes, 2 <= p < n """
    n, correction = n-n%6+6, 2-(n%6>1)
    sieve = [True] * (n//3)
    for i in range(1,int(n**0.5)//3+1):
      if sieve[i]:
        k=3*i+1|1
        sieve[      k*k//3      ::2*k] = [False] * ((n//6-k*k//6-1)//k+1)
        sieve[k*(k-2*(i&1)+4)//3::2*k] = [False] * ((n//6-k*(k-2*(i&1)+4)//6-1)//k+1)
    return [2,3] + [3*i+1|1 for i in range(1,n//3-correction) if sieve[i]]

Sayangnya pure-python tidak mengadopsi cara numpy yang lebih sederhana dan cepat dalam melakukan penugasan, dan memanggil len()di dalam loop karena [False]*len(sieve[((k*k)//3)::2*k])terlalu lambat. Jadi saya harus berimprovisasi untuk mengoreksi input (& menghindari lebih banyak matematika) dan melakukan beberapa sihir matematika yang ekstrim (& menyakitkan).

Secara pribadi saya pikir itu memalukan bahwa numpy (yang begitu banyak digunakan) bukan bagian dari pustaka standar Python, dan bahwa perbaikan dalam sintaks dan kecepatan tampaknya sepenuhnya diabaikan oleh pengembang Python.


2
Numpy sekarang kompatibel dengan Python 3. Fakta bahwa itu tidak ada di perpustakaan standar adalah baik, dengan cara itu mereka dapat memiliki siklus rilis mereka sendiri.
Adam

hanya menyimpan nilai-nilai biner dalam array saya sarankan bitarray- seperti yang digunakan di sini (untuk saringan utama yang paling sederhana; bukan pesaing dalam lomba di sini!) stackoverflow.com/questions/31120986/...
hiro protagonis

Saat melakukan casting dalam primesfrom2to()metode, haruskah pembagian berada di dalam kurung?
355durch113

3
Untuk versi python murni yang kompatibel dengan python 3, ikuti tautan ini: stackoverflow.com/a/33356284/2482582
Moebius

1
Buttsnacks suci pengisap ini cepat.
Scott

42

Ada contoh yang cukup rapi dari Python Cookbook di sini - versi tercepat yang diajukan pada URL itu adalah:

import itertools
def erat2( ):
    D = {  }
    yield 2
    for q in itertools.islice(itertools.count(3), 0, None, 2):
        p = D.pop(q, None)
        if p is None:
            D[q*q] = q
            yield q
        else:
            x = p + q
            while x in D or not (x&1):
                x += p
            D[x] = p

jadi itu akan memberi

def get_primes_erat(n):
  return list(itertools.takewhile(lambda p: p<n, erat2()))

Mengukur pada prompt shell (seperti yang saya suka lakukan) dengan kode ini di pri.py, saya perhatikan:

$ python2.5 -mtimeit -s'import pri' 'pri.get_primes(1000000)'
10 loops, best of 3: 1.69 sec per loop
$ python2.5 -mtimeit -s'import pri' 'pri.get_primes_erat(1000000)'
10 loops, best of 3: 673 msec per loop

jadi sepertinya solusi Cookbook lebih dari dua kali lebih cepat.


1
@ jbochi, sama-sama - tetapi lihatlah URL itu, termasuk kreditnya: butuh sepuluh dari kita untuk secara kolektif memperbaiki kode ke titik ini, termasuk tokoh-tokoh kinerja Python seperti Tim Peters dan Raymond Hettinger (saya menulis teks terakhir dari resep sejak saya mengedit Cookbook yang dicetak, tetapi dalam hal pengkodean, kontribusi saya setara dengan yang lain ') - pada akhirnya, itu benar-benar kode yang tersamar dan halus, dan itu tidak mengejutkan! -)
Alex Martelli

@ Alex: Mengetahui bahwa kode Anda "hanya" dua kali lebih cepat dari milik saya, membuat saya cukup bangga. :) URL-nya juga sangat menarik untuk dibaca. Terima kasih lagi.
jbochi

Dan itu dapat dibuat lebih cepat dengan perubahan kecil: lihat stackoverflow.com/questions/2211990/…
tzot

1
... Dan ini dapat dibuat lebih cepat dengan tambahan ~ 1.2x-1.3x speedup, pengurangan drastis jejak memori dari O (n) ke O (sqrt (n)) dan peningkatan kompleksitas waktu empiris, dengan menunda penambahan primes ke dict sampai kotak mereka terlihat di input. Uji di sini .
Will Ness

28

Dengan menggunakan Saringan Sundaram , saya pikir saya memecahkan rekor Python murni:

def sundaram3(max_n):
    numbers = range(3, max_n+1, 2)
    half = (max_n)//2
    initial = 4

    for step in xrange(3, max_n+1, 2):
        for i in xrange(initial, half, step):
            numbers[i-1] = 0
        initial += 2*(step+1)

        if initial > half:
            return [2] + filter(None, numbers)

Perbandingan:

C:\USERS>python -m timeit -n10 -s "import get_primes" "get_primes.get_primes_erat(1000000)"
10 loops, best of 3: 710 msec per loop

C:\USERS>python -m timeit -n10 -s "import get_primes" "get_primes.daniel_sieve_2(1000000)"
10 loops, best of 3: 435 msec per loop

C:\USERS>python -m timeit -n10 -s "import get_primes" "get_primes.sundaram3(1000000)"
10 loops, best of 3: 327 msec per loop

1
Saya berhasil mempercepat fungsi Anda sekitar 20% dengan menambahkan "nol = 0" di bagian atas fungsi dan kemudian mengganti lambda di filter Anda dengan "nol .__ sub__". Bukan kode tercantik di dunia, tapi sedikit lebih cepat :)
truppo

1
@truppo: Terima kasih atas komentar Anda! Saya baru menyadari bahwa lewat Nonealih-alih fungsi asli berfungsi dan itu bahkan lebih cepat daripadazero.__sub__
jbochi

7
Tahukah Anda bahwa jika Anda lulus sundaram3(9)akan kembali [2, 3, 5, 7, 9]? Tampaknya melakukan ini dengan banyak - mungkin semua - angka ganjil (bahkan ketika mereka tidak prima)
wrhall

1
ia memiliki masalah: sundaram3 (7071) termasuk 7071 sementara tidak prima
bigOther

18

Algoritma ini cepat, tetapi memiliki kelemahan serius:

>>> sorted(get_primes(530))
[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, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163,
167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251,
257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349,
353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443,
449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 527, 529]
>>> 17*31
527
>>> 23*23
529

Anda menganggap bahwa numbers.pop()akan mengembalikan angka terkecil di set, tetapi ini tidak dijamin sama sekali. Set tidak berurutan dan pop()menghapus serta mengembalikan elemen arbitrer , sehingga tidak dapat digunakan untuk memilih prime berikutnya dari angka yang tersisa.


17

Untuk benar-benar solusi tercepat dengan N cukup besar akan men-download daftar pra-dihitung dari bilangan prima , menyimpannya sebagai tupel dan melakukan sesuatu seperti:

for pos,i in enumerate(primes):
    if i > N:
        print primes[:pos]

Jika N > primes[-1] hanya kemudian menghitung lebih banyak bilangan prima dan menyimpan daftar baru dalam kode Anda, jadi lain kali sama cepatnya.

Selalu berpikir di luar kotak.


9
Agar adil, Anda harus menghitung waktu mengunduh, membuka ritsleting, dan memformat bilangan prima dan membandingkannya dengan waktu untuk menghasilkan bilangan prima menggunakan algoritma - salah satu dari algoritma ini dapat dengan mudah menulis hasil ke file untuk nanti menggunakan. Saya pikir dalam hal ini, mengingat memori yang cukup untuk benar-benar menghitung semua bilangan prima kurang dari 982.451.653, solusi numpy masih akan lebih cepat.
Daniel G

3
@Aniel benar. Namun toko apa yang Anda miliki dan lanjutkan kapanpun dibutuhkan masih ada ...
Kimvais

@Daniel GI berpikir waktu mengunduh tidak relevan. Bukankah ini benar-benar tentang menghasilkan angka, sehingga Anda ingin mempertimbangkan algoritma yang digunakan untuk membuat daftar yang Anda unduh. Dan kompleksitas waktu akan mengabaikan transfer file sekali diberikan O (n).
Ross

The FAQ untuk UTM halaman utama menunjukkan menghitung bilangan prima kecil lebih cepat daripada membaca mereka dari disk (pertanyaannya adalah apa artinya kecil).
Batman

12

Jika Anda tidak ingin menemukan kembali roda, Anda dapat menginstal sympy library simbolik matematika (ya itu kompatibel dengan Python 3)

pip install sympy

Dan gunakan fungsi primerange

from sympy import sieve
primes = list(sieve.primerange(1, 10**6))

8

Jika Anda menerima itertools tetapi tidak numpy, ini adalah adaptasi dari rwh_primes2 untuk Python 3 yang berjalan sekitar dua kali lebih cepat di komputer saya. Satu-satunya perubahan substansial adalah menggunakan bytearray alih-alih daftar untuk boolean, dan menggunakan kompres alih-alih pemahaman daftar untuk membangun daftar akhir. (Saya akan menambahkan ini sebagai komentar seperti moarningsun jika saya bisa.)

import itertools
izip = itertools.zip_longest
chain = itertools.chain.from_iterable
compress = itertools.compress
def rwh_primes2_python3(n):
    """ Input n>=6, Returns a list of primes, 2 <= p < n """
    zero = bytearray([False])
    size = n//3 + (n % 6 == 2)
    sieve = bytearray([True]) * size
    sieve[0] = False
    for i in range(int(n**0.5)//3+1):
      if sieve[i]:
        k=3*i+1|1
        start = (k*k+4*k-2*k*(i&1))//3
        sieve[(k*k)//3::2*k]=zero*((size - (k*k)//3 - 1) // (2 * k) + 1)
        sieve[  start ::2*k]=zero*((size -   start  - 1) // (2 * k) + 1)
    ans = [2,3]
    poss = chain(izip(*[range(i, n, 6) for i in (1,5)]))
    ans.extend(compress(poss, sieve))
    return ans

Perbandingan:

>>> timeit.timeit('primes.rwh_primes2(10**6)', setup='import primes', number=1)
0.0652179726976101
>>> timeit.timeit('primes.rwh_primes2_python3(10**6)', setup='import primes', number=1)
0.03267321276325674

dan

>>> timeit.timeit('primes.rwh_primes2(10**8)', setup='import primes', number=1)
6.394284538007014
>>> timeit.timeit('primes.rwh_primes2_python3(10**8)', setup='import primes', number=1)
3.833829450302801

Implementasinya sangat keren. :)
Krish

7

Sangat membantu untuk menulis kode penemuan utama Anda sendiri, tetapi juga bermanfaat untuk memiliki perpustakaan yang andal dan cepat. Saya menulis pembungkus di sekitar C ++ library primesieve , menamainya primesieve-python

Cobalah pip install primesieve

import primesieve
primes = primesieve.generate_primes(10**8)

Saya ingin tahu melihat kecepatan dibandingkan.


Ini tidak persis apa yang dipesan OP tetapi saya gagal melihat mengapa downvote. Ini adalah solusi 2.8sec tidak seperti beberapa modul luar lainnya. Saya perhatikan di sumbernya bahwa itu di-threaded, ada tes tentang seberapa baik itu bersisik?
ljetibo

@ljetibo bersorak. Kemacetan tampaknya akan menyalin vektor C ++ ke daftar Python, sehingga count_primesfungsinya jauh lebih cepat daripadagenerate_primes
Kolonel Panic

Di komputer saya ia dapat dengan nyaman menghasilkan primes hingga 1e8 (ia memberi MemoryError untuk 1e9), dan menghitung primes hingga 1e10. @ HappyLeapSecond di atas membandingkan algoritma untuk 1e6
Kolonel Panic

7

Berikut adalah dua versi yang diperbarui (pure Python 3.6) dari salah satu fungsi tercepat,

from itertools import compress

def rwh_primes1v1(n):
    """ Returns  a list of primes < n for n > 2 """
    sieve = bytearray([True]) * (n//2)
    for i in range(3,int(n**0.5)+1,2):
        if sieve[i//2]:
            sieve[i*i//2::i] = bytearray((n-i*i-1)//(2*i)+1)
    return [2,*compress(range(3,n,2), sieve[1:])]

def rwh_primes1v2(n):
    """ Returns a list of primes < n for n > 2 """
    sieve = bytearray([True]) * (n//2+1)
    for i in range(1,int(n**0.5)//2+1):
        if sieve[i]:
            sieve[2*i*(i+1)::2*i+1] = bytearray((n//2-2*i*(i+1))//(2*i+1)+1)
    return [2,*compress(range(3,n,2), sieve[1:])]

1
Dalam Python 3 saya menggunakan fungsi ini stackoverflow.com/a/3035188/7799269 tetapi diganti / dengan // dan xrange dengan jangkauan dan mereka tampak jauh lebih cepat dari ini.
samerivertwice

4

Implementasi deterministik dari uji Primality Miller-Rabin dengan asumsi bahwa N <9.080.191

import sys
import random

def miller_rabin_pass(a, n):
    d = n - 1
    s = 0
    while d % 2 == 0:
        d >>= 1
        s += 1

    a_to_power = pow(a, d, n)
    if a_to_power == 1:
        return True
    for i in xrange(s-1):
        if a_to_power == n - 1:
            return True
        a_to_power = (a_to_power * a_to_power) % n
    return a_to_power == n - 1


def miller_rabin(n):
    for a in [2, 3, 37, 73]:
      if not miller_rabin_pass(a, n):
        return False
    return True


n = int(sys.argv[1])
primes = [2]
for p in range(3,n,2):
  if miller_rabin(p):
    primes.append(p)
print len(primes)

Menurut artikel di Wikipedia ( http://en.wikipedia.org/wiki/Miller–Rabin_primality_test ) menguji N <9.080.191 untuk a = 2,3,37, dan 73 sudah cukup untuk memutuskan apakah N adalah komposit atau tidak.

Dan saya mengadaptasi kode sumber dari implementasi probabilistik uji Miller-Rabin asli yang ditemukan di sini: http://en.literateprograms.org/Miller-Rabin_primality_test_(Python)


1
Terima kasih atas uji keutamaan Miller-Rabin, tetapi kode ini sebenarnya lebih lambat dan tidak memberikan hasil yang benar. 37 adalah prima dan tidak lulus ujian.
jbochi

Saya kira 37 adalah salah satu kasus khusus, buruk saya. Saya berharap tentang versi deterministik :)
Ruggiero Spearman

Tidak ada kasus khusus untuk pembuat rabin.
Salah kaprah,

2
Anda salah membaca artikel. Ini 31, bukan 37. Inilah sebabnya mengapa implementasi Anda gagal.
Logan

4

Jika Anda memiliki kendali atas N, cara paling cepat untuk membuat daftar semua bilangan prima adalah dengan melakukannya. Serius. Precomputing adalah cara optimasi yang terlewatkan.


3
Atau unduh dari sini primes.utm.edu/lists/small/millions , tetapi idenya adalah untuk menguji batas python dan melihat apakah kode yang indah muncul dari optimasi.
jbochi

4

Berikut kode yang biasanya saya gunakan untuk menghasilkan bilangan prima dengan Python:

$ python -mtimeit -s'import sieve' 'sieve.sieve(1000000)' 
10 loops, best of 3: 445 msec per loop
$ cat sieve.py
from math import sqrt

def sieve(size):
 prime=[True]*size
 rng=xrange
 limit=int(sqrt(size))

 for i in rng(3,limit+1,+2):
  if prime[i]:
   prime[i*i::+i]=[False]*len(prime[i*i::+i])

 return [2]+[i for i in rng(3,size,+2) if prime[i]]

if __name__=='__main__':
 print sieve(100)

Itu tidak dapat bersaing dengan solusi lebih cepat yang diposting di sini, tetapi setidaknya itu adalah python murni.

Terima kasih telah mengirimkan pertanyaan ini. Saya benar-benar belajar banyak hari ini.


3

Untuk kode tercepat, solusi numpy adalah yang terbaik. Untuk alasan akademis murni, saya memposting versi python murni saya, yang sedikit kurang dari 50% lebih cepat dari versi buku resep yang diposting di atas. Karena saya membuat seluruh daftar dalam memori, Anda membutuhkan ruang yang cukup untuk menampung semuanya, tetapi tampaknya skalanya cukup baik.

def daniel_sieve_2(maxNumber):
    """
    Given a number, returns all numbers less than or equal to
    that number which are prime.
    """
    allNumbers = range(3, maxNumber+1, 2)
    for mIndex, number in enumerate(xrange(3, maxNumber+1, 2)):
        if allNumbers[mIndex] == 0:
            continue
        # now set all multiples to 0
        for index in xrange(mIndex+number, (maxNumber-3)/2+1, number):
            allNumbers[index] = 0
    return [2] + filter(lambda n: n!=0, allNumbers)

Dan hasilnya:

>>>mine = timeit.Timer("daniel_sieve_2(1000000)",
...                    "from sieves import daniel_sieve_2")
>>>prev = timeit.Timer("get_primes_erat(1000000)",
...                    "from sieves import get_primes_erat")
>>>print "Mine: {0:0.4f} ms".format(min(mine.repeat(3, 1))*1000)
Mine: 428.9446 ms
>>>print "Previous Best {0:0.4f} ms".format(min(prev.repeat(3, 1))*1000)
Previous Best 621.3581 ms

3

Implementasi yang sedikit berbeda dari saringan setengah menggunakan Numpy:

http://rebrained.com/?p=458

impor matematika
impor numpy
def prime6 (upto):
    primes = numpy.arange (3, hingga + 1,2)
    isprime = numpy.ones ((up-1) / 2, dtype = bool)
    untuk faktor bilangan prima [: int (math.sqrt (upto))]:
        jika isprime [(faktor-2) / 2]: isprime [(faktor * 3-2) / 2: (hingga-1) / 2: faktor] = 0
    return numpy.insert (primes [isprime], 0,2)

Bisakah seseorang membandingkan ini dengan timing lainnya? Di komputer saya sepertinya cukup sebanding dengan setengah-saringan Numpy lainnya.


upto=10**6: primesfrom2to()- 7 ms; prime6()- 12 ms ideone.com/oDg2Y
jfs

3

Semuanya ditulis dan diuji. Jadi tidak perlu menemukan kembali roda.

python -m timeit -r10 -s"from sympy import sieve" "primes = list(sieve.primerange(1, 10**6))"

memberi kami pemecahan rekor 12.2 msec !

10 loops, best of 10: 12.2 msec per loop

Jika ini tidak cukup cepat, Anda dapat mencoba PyPy:

pypy -m timeit -r10 -s"from sympy import sieve" "primes = list(sieve.primerange(1, 10**6))"

yang mengakibatkan:

10 loops, best of 10: 2.03 msec per loop

Jawaban dengan 247 daftar suara mendaftar 15,9 ms untuk solusi terbaik. Bandingkan ini !!!


3

Saya menguji beberapa fungsi unutbu , saya menghitungnya dengan angka jutaan hungred

Pemenangnya adalah fungsi yang menggunakan perpustakaan numpy,

Catatan : Ini juga akan menarik untuk melakukan tes pemanfaatan memori :)

Hasil waktu perhitungan

Kode sampel

Kode lengkap di repositori github saya

#!/usr/bin/env python

import lib
import timeit
import sys
import math
import datetime

import prettyplotlib as ppl
import numpy as np

import matplotlib.pyplot as plt
from prettyplotlib import brewer2mpl

primenumbers_gen = [
    'sieveOfEratosthenes',
    'ambi_sieve',
    'ambi_sieve_plain',
    'sundaram3',
    'sieve_wheel_30',
    'primesfrom3to',
    'primesfrom2to',
    'rwh_primes',
    'rwh_primes1',
    'rwh_primes2',
]

def human_format(num):
    # /programming/579310/formatting-long-numbers-as-strings-in-python?answertab=active#tab-top
    magnitude = 0
    while abs(num) >= 1000:
        magnitude += 1
        num /= 1000.0
    # add more suffixes if you need them
    return '%.2f%s' % (num, ['', 'K', 'M', 'G', 'T', 'P'][magnitude])


if __name__=='__main__':

    # Vars
    n = 10000000 # number itereration generator
    nbcol = 5 # For decompose prime number generator
    nb_benchloop = 3 # Eliminate false positive value during the test (bench average time)
    datetimeformat = '%Y-%m-%d %H:%M:%S.%f'
    config = 'from __main__ import n; import lib'
    primenumbers_gen = {
        'sieveOfEratosthenes': {'color': 'b'},
        'ambi_sieve': {'color': 'b'},
        'ambi_sieve_plain': {'color': 'b'},
         'sundaram3': {'color': 'b'},
        'sieve_wheel_30': {'color': 'b'},
# # #        'primesfrom2to': {'color': 'b'},
        'primesfrom3to': {'color': 'b'},
        # 'rwh_primes': {'color': 'b'},
        # 'rwh_primes1': {'color': 'b'},
        'rwh_primes2': {'color': 'b'},
    }


    # Get n in command line
    if len(sys.argv)>1:
        n = int(sys.argv[1])

    step = int(math.ceil(n / float(nbcol)))
    nbs = np.array([i * step for i in range(1, int(nbcol) + 1)])
    set2 = brewer2mpl.get_map('Paired', 'qualitative', 12).mpl_colors

    print datetime.datetime.now().strftime(datetimeformat)
    print("Compute prime number to %(n)s" % locals())
    print("")

    results = dict()
    for pgen in primenumbers_gen:
        results[pgen] = dict()
        benchtimes = list()
        for n in nbs:
            t = timeit.Timer("lib.%(pgen)s(n)" % locals(), setup=config)
            execute_times = t.repeat(repeat=nb_benchloop,number=1)
            benchtime = np.mean(execute_times)
            benchtimes.append(benchtime)
        results[pgen] = {'benchtimes':np.array(benchtimes)}

fig, ax = plt.subplots(1)
plt.ylabel('Computation time (in second)')
plt.xlabel('Numbers computed')
i = 0
for pgen in primenumbers_gen:

    bench = results[pgen]['benchtimes']
    avgs = np.divide(bench,nbs)
    avg = np.average(bench, weights=nbs)

    # Compute linear regression
    A = np.vstack([nbs, np.ones(len(nbs))]).T
    a, b = np.linalg.lstsq(A, nbs*avgs)[0]

    # Plot
    i += 1
    #label="%(pgen)s" % locals()
    #ppl.plot(nbs, nbs*avgs, label=label, lw=1, linestyle='--', color=set2[i % 12])
    label="%(pgen)s avg" % locals()
    ppl.plot(nbs, a * nbs + b, label=label, lw=2, color=set2[i % 12])
print datetime.datetime.now().strftime(datetimeformat)

ppl.legend(ax, loc='upper left', ncol=4)

# Change x axis label
ax.get_xaxis().get_major_formatter().set_scientific(False)
fig.canvas.draw()
labels = [human_format(int(item.get_text())) for item in ax.get_xticklabels()]

ax.set_xticklabels(labels)
ax = plt.gca()

plt.show()

2
untuk membandingkan kinerja algoritmik , lebih baik buat plot pada skala log-log .
Will Ness

3

Untuk Python 3

def rwh_primes2(n):
    correction = (n%6>1)
    n = {0:n,1:n-1,2:n+4,3:n+3,4:n+2,5:n+1}[n%6]
    sieve = [True] * (n//3)
    sieve[0] = False
    for i in range(int(n**0.5)//3+1):
      if sieve[i]:
        k=3*i+1|1
        sieve[      ((k*k)//3)      ::2*k]=[False]*((n//6-(k*k)//6-1)//k+1)
        sieve[(k*k+4*k-2*k*(i&1))//3::2*k]=[False]*((n//6-(k*k+4*k-2*k*(i&1))//6-1)//k+1)
    return [2,3] + [3*i+1|1 for i in range(1,n//3-correction) if sieve[i]]

3

Saringan perdana tercepat di Pure Python :

from itertools import compress

def half_sieve(n):
    """
    Returns a list of prime numbers less than `n`.
    """
    if n <= 2:
        return []
    sieve = bytearray([True]) * (n // 2)
    for i in range(3, int(n ** 0.5) + 1, 2):
        if sieve[i // 2]:
            sieve[i * i // 2::i] = bytearray((n - i * i - 1) // (2 * i) + 1)
    primes = list(compress(range(1, n, 2), sieve))
    primes[0] = 2
    return primes

Saya dioptimalkan Saringan Eratosthenes untuk kecepatan dan memori.

Tolok ukur

from time import clock
import platform

def benchmark(iterations, limit):
    start = clock()
    for x in range(iterations):
        half_sieve(limit)
    end = clock() - start
    print(f'{end/iterations:.4f} seconds for primes < {limit}')

if __name__ == '__main__':
    print(platform.python_version())
    print(platform.platform())
    print(platform.processor())
    it = 10
    for pw in range(4, 9):
        benchmark(it, 10**pw)

Keluaran

>>> 3.6.7
>>> Windows-10-10.0.17763-SP0
>>> Intel64 Family 6 Model 78 Stepping 3, GenuineIntel
>>> 0.0003 seconds for primes < 10000
>>> 0.0021 seconds for primes < 100000
>>> 0.0204 seconds for primes < 1000000
>>> 0.2389 seconds for primes < 10000000
>>> 2.6702 seconds for primes < 100000000

2

Pertama kali menggunakan python, jadi beberapa metode yang saya gunakan dalam hal ini mungkin terlihat sedikit rumit. Saya langsung mengkonversikan kode c ++ saya ke python dan inilah yang saya miliki (walaupun sedikit lambat di python)

#!/usr/bin/env python
import time

def GetPrimes(n):

    Sieve = [1 for x in xrange(n)]

    Done = False
    w = 3

    while not Done:

        for q in xrange (3, n, 2):
            Prod = w*q
            if Prod < n:
                Sieve[Prod] = 0
            else:
                break

        if w > (n/2):
            Done = True
        w += 2

    return Sieve



start = time.clock()

d = 10000000
Primes = GetPrimes(d)

count = 1 #This is for 2

for x in xrange (3, d, 2):
    if Primes[x]:
        count+=1

elapsed = (time.clock() - start)
print "\nFound", count, "primes in", elapsed, "seconds!\n"

pythonw Primes.py

Ditemukan 664579 bilangan prima dalam 12,799119 detik!

#!/usr/bin/env python
import time

def GetPrimes2(n):

    Sieve = [1 for x in xrange(n)]

    for q in xrange (3, n, 2):
        k = q
        for y in xrange(k*3, n, k*2):
            Sieve[y] = 0

    return Sieve



start = time.clock()

d = 10000000
Primes = GetPrimes2(d)

count = 1 #This is for 2

for x in xrange (3, d, 2):
    if Primes[x]:
        count+=1

elapsed = (time.clock() - start)
print "\nFound", count, "primes in", elapsed, "seconds!\n"

pythonw Primes2.py

Ditemukan 664579 bilangan prima dalam 10,230172 detik!

#!/usr/bin/env python
import time

def GetPrimes3(n):

    Sieve = [1 for x in xrange(n)]

    for q in xrange (3, n, 2):
        k = q
        for y in xrange(k*k, n, k << 1):
            Sieve[y] = 0

    return Sieve



start = time.clock()

d = 10000000
Primes = GetPrimes3(d)

count = 1 #This is for 2

for x in xrange (3, d, 2):
    if Primes[x]:
        count+=1

elapsed = (time.clock() - start)
print "\nFound", count, "primes in", elapsed, "seconds!\n"

python Primes2.py

Ditemukan 664579 bilangan prima dalam 7,113776 detik!


2

Saya tahu kompetisi ditutup selama beberapa tahun. ...

Meskipun demikian ini adalah saran saya untuk saringan prime python murni, berdasarkan menghilangkan kelipatan 2, 3 dan 5 dengan menggunakan langkah-langkah yang tepat saat memproses ayakan maju. Meskipun demikian sebenarnya lebih lambat untuk N <10 ^ 9 daripada @Robert William Hanks solusi superior rwh_primes2 dan rwh_primes1. Dengan menggunakan array saringan ctypes.c_ushort di atas 1,5 * 10 ^ 8 itu entah bagaimana adaptif dengan batas memori.

10 ^ 6

$ python -mtimeit -s "import primeSieveSpeedComp" "primeSieveSpeedComp.primeSieveSeq (1000000)" 10 loop, terbaik 3: 46,7 msec per loop

untuk membandingkan: $ python -mtimeit -s "import primeSieveSpeedComp" "primeSieveSpeedComp.rwh_primes1 (1000000)" 10 loop, terbaik dari 3: 43,2 msec per loop untuk membandingkan: $ python -m timeit -s "import primeSieveSpeedComp" "primeSieveSpeedComp.rwh_primes_primes_primes1 (1000000) "10 loop, terbaik 3: 34,5 msec per loop

10 ^ 7

$ python -mtimeit -s "import primeSieveSpeedComp" "primeSieveSpeedComp.primeSieveSeq (10000000)" 10 loop, terbaik 3: 530 msec per loop

untuk membandingkan: $ python -mtimeit -s "import primeSieveSpeedComp" "primeSieveSpeedComp.rwh_primes1 (10000000)" 10 loop, terbaik dari 3: 494 msec per loop untuk membandingkan: $ python -m timeit -s "import primeSieveSpeedComp" "primeSieveSpeedComp.rwh (10000000) "10 loop, terbaik 3: 375 msec per loop

10 ^ 8

$ python -mtimeit -s "import primeSieveSpeedComp" "primeSieveSpeedComp.primeSieveSeq (100000000)" 10 loop, terbaik 3: 5,55 detik per loop

untuk membandingkan: $ python -mtimeit -s "import primeSieveSpeedComp" "primeSieveSpeedComp.rwh_primes1 (100000000)" 10 loop, terbaik dari 3: 5,33 detik per loop untuk membandingkan: $ python -m timeit -s "import primeSieveSpeedComp" "primeSieveSpeedComp.rwh (100000000) "10 loop, terbaik 3: 3,95 detik per loop

10 ^ 9

$ python -mtimeit -s "import primeSieveSpeedComp" "primeSieveSpeedComp.primeSieveSeq (1000000000)" 10 loop, terbaik 3: 61,2 detik per loop

untuk membandingkan: $ python -mtimeit -n 3 -s "import primeSieveSpeedComp" "primeSieveSpeedComp.rwh_primes1 (1000000000)" 3 loop, terbaik 3: 97,8 detik per loop

untuk membandingkan: $ python -m timeit -s "import primeSieveSpeedComp" "primeSieveSpeedComp.rwh_primes2 (1000000000)" 10 loop, terbaik 3: 41,9 detik per loop

Anda dapat menyalin kode di bawah ini ke ubuntus primeSieveSpeedComp untuk meninjau tes ini.

def primeSieveSeq(MAX_Int):
    if MAX_Int > 5*10**8:
        import ctypes
        int16Array = ctypes.c_ushort * (MAX_Int >> 1)
        sieve = int16Array()
        #print 'uses ctypes "unsigned short int Array"'
    else:
        sieve = (MAX_Int >> 1) * [False]
        #print 'uses python list() of long long int'
    if MAX_Int < 10**8:
        sieve[4::3] = [True]*((MAX_Int - 8)/6+1)
        sieve[12::5] = [True]*((MAX_Int - 24)/10+1)
    r = [2, 3, 5]
    n = 0
    for i in xrange(int(MAX_Int**0.5)/30+1):
        n += 3
        if not sieve[n]:
            n2 = (n << 1) + 1
            r.append(n2)
            n2q = (n2**2) >> 1
            sieve[n2q::n2] = [True]*(((MAX_Int >> 1) - n2q - 1) / n2 + 1)
        n += 2
        if not sieve[n]:
            n2 = (n << 1) + 1
            r.append(n2)
            n2q = (n2**2) >> 1
            sieve[n2q::n2] = [True]*(((MAX_Int >> 1) - n2q - 1) / n2 + 1)
        n += 1
        if not sieve[n]:
            n2 = (n << 1) + 1
            r.append(n2)
            n2q = (n2**2) >> 1
            sieve[n2q::n2] = [True]*(((MAX_Int >> 1) - n2q - 1) / n2 + 1)
        n += 2
        if not sieve[n]:
            n2 = (n << 1) + 1
            r.append(n2)
            n2q = (n2**2) >> 1
            sieve[n2q::n2] = [True]*(((MAX_Int >> 1) - n2q - 1) / n2 + 1)
        n += 1
        if not sieve[n]:
            n2 = (n << 1) + 1
            r.append(n2)
            n2q = (n2**2) >> 1
            sieve[n2q::n2] = [True]*(((MAX_Int >> 1) - n2q - 1) / n2 + 1)
        n += 2
        if not sieve[n]:
            n2 = (n << 1) + 1
            r.append(n2)
            n2q = (n2**2) >> 1
            sieve[n2q::n2] = [True]*(((MAX_Int >> 1) - n2q - 1) / n2 + 1)
        n += 3
        if not sieve[n]:
            n2 = (n << 1) + 1
            r.append(n2)
            n2q = (n2**2) >> 1
            sieve[n2q::n2] = [True]*(((MAX_Int >> 1) - n2q - 1) / n2 + 1)
        n += 1
        if not sieve[n]:
            n2 = (n << 1) + 1
            r.append(n2)
            n2q = (n2**2) >> 1
            sieve[n2q::n2] = [True]*(((MAX_Int >> 1) - n2q - 1) / n2 + 1)
    if MAX_Int < 10**8:
        return [2, 3, 5]+[(p << 1) + 1 for p in [n for n in xrange(3, MAX_Int >> 1) if not sieve[n]]]
    n = n >> 1
    try:
        for i in xrange((MAX_Int-2*n)/30 + 1):
            n += 3
            if not sieve[n]:
                r.append((n << 1) + 1)
            n += 2
            if not sieve[n]:
                r.append((n << 1) + 1)
            n += 1
            if not sieve[n]:
                r.append((n << 1) + 1)
            n += 2
            if not sieve[n]:
                r.append((n << 1) + 1)
            n += 1
            if not sieve[n]:
                r.append((n << 1) + 1)
            n += 2
            if not sieve[n]:
                r.append((n << 1) + 1)
            n += 3
            if not sieve[n]:
                r.append((n << 1) + 1)
            n += 1
            if not sieve[n]:
                r.append((n << 1) + 1)
    except:
        pass
    return r

untuk memvisualisasikan hasil tes Anda, plot mereka pada skala log-log, untuk melihat dan membandingkan urutan pertumbuhan empiris .
Will Ness

@ Will terima kasih atas masukannya, saya akan memikirkan ini lain kali saya membutuhkan perbandingan seperti itu
ABri

1

Berikut ini adalah versi Saringan Eratosthenes yang numpy yang memiliki kompleksitas yang baik (lebih rendah daripada menyortir array dengan panjang n) dan vektorisasi. Dibandingkan dengan @unutbu kali ini secepat paket dengan 46 mikron untuk menemukan semua bilangan prima di bawah satu juta.

import numpy as np 
def generate_primes(n):
    is_prime = np.ones(n+1,dtype=bool)
    is_prime[0:2] = False
    for i in range(int(n**0.5)+1):
        if is_prime[i]:
            is_prime[i**2::i]=False
    return np.where(is_prime)[0]

Pengaturan waktu:

import time    
for i in range(2,10):
    timer =time.time()
    generate_primes(10**i)
    print('n = 10^',i,' time =', round(time.time()-timer,6))

>> n = 10^ 2  time = 5.6e-05
>> n = 10^ 3  time = 6.4e-05
>> n = 10^ 4  time = 0.000114
>> n = 10^ 5  time = 0.000593
>> n = 10^ 6  time = 0.00467
>> n = 10^ 7  time = 0.177758
>> n = 10^ 8  time = 1.701312
>> n = 10^ 9  time = 19.322478

1

Saya telah memperbarui banyak kode untuk Python 3 dan melemparkannya di perfplot (proyek saya) untuk melihat mana yang sebenarnya tercepat. Ternyata, untuk yang besar n, primesfrom{2,3}toambil kue:

masukkan deskripsi gambar di sini


Kode untuk mereproduksi plot:

import perfplot
from math import sqrt, ceil
import numpy as np
import sympy


def rwh_primes(n):
    # /programming/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    """ Returns  a list of primes < n """
    sieve = [True] * n
    for i in range(3, int(n ** 0.5) + 1, 2):
        if sieve[i]:
            sieve[i * i::2 * i] = [False] * ((n - i * i - 1) // (2 * i) + 1)
    return [2] + [i for i in range(3, n, 2) if sieve[i]]


def rwh_primes1(n):
    # /programming/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    """ Returns  a list of primes < n """
    sieve = [True] * (n // 2)
    for i in range(3, int(n ** 0.5) + 1, 2):
        if sieve[i // 2]:
            sieve[i * i // 2::i] = [False] * ((n - i * i - 1) // (2 * i) + 1)
    return [2] + [2 * i + 1 for i in range(1, n // 2) if sieve[i]]


def rwh_primes2(n):
    # /programming/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    """Input n>=6, Returns a list of primes, 2 <= p < n"""
    assert n >= 6
    correction = n % 6 > 1
    n = {0: n, 1: n - 1, 2: n + 4, 3: n + 3, 4: n + 2, 5: n + 1}[n % 6]
    sieve = [True] * (n // 3)
    sieve[0] = False
    for i in range(int(n ** 0.5) // 3 + 1):
        if sieve[i]:
            k = 3 * i + 1 | 1
            sieve[((k * k) // 3)::2 * k] = [False] * (
                (n // 6 - (k * k) // 6 - 1) // k + 1
            )
            sieve[(k * k + 4 * k - 2 * k * (i & 1)) // 3::2 * k] = [False] * (
                (n // 6 - (k * k + 4 * k - 2 * k * (i & 1)) // 6 - 1) // k + 1
            )
    return [2, 3] + [3 * i + 1 | 1 for i in range(1, n // 3 - correction) if sieve[i]]


def sieve_wheel_30(N):
    # http://zerovolt.com/?p=88
    """ Returns a list of primes <= N using wheel criterion 2*3*5 = 30

Copyright 2009 by zerovolt.com
This code is free for non-commercial purposes, in which case you can just leave this comment as a credit for my work.
If you need this code for commercial purposes, please contact me by sending an email to: info [at] zerovolt [dot] com."""
    __smallp = (
        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,
        107,
        109,
        113,
        127,
        131,
        137,
        139,
        149,
        151,
        157,
        163,
        167,
        173,
        179,
        181,
        191,
        193,
        197,
        199,
        211,
        223,
        227,
        229,
        233,
        239,
        241,
        251,
        257,
        263,
        269,
        271,
        277,
        281,
        283,
        293,
        307,
        311,
        313,
        317,
        331,
        337,
        347,
        349,
        353,
        359,
        367,
        373,
        379,
        383,
        389,
        397,
        401,
        409,
        419,
        421,
        431,
        433,
        439,
        443,
        449,
        457,
        461,
        463,
        467,
        479,
        487,
        491,
        499,
        503,
        509,
        521,
        523,
        541,
        547,
        557,
        563,
        569,
        571,
        577,
        587,
        593,
        599,
        601,
        607,
        613,
        617,
        619,
        631,
        641,
        643,
        647,
        653,
        659,
        661,
        673,
        677,
        683,
        691,
        701,
        709,
        719,
        727,
        733,
        739,
        743,
        751,
        757,
        761,
        769,
        773,
        787,
        797,
        809,
        811,
        821,
        823,
        827,
        829,
        839,
        853,
        857,
        859,
        863,
        877,
        881,
        883,
        887,
        907,
        911,
        919,
        929,
        937,
        941,
        947,
        953,
        967,
        971,
        977,
        983,
        991,
        997,
    )
    # wheel = (2, 3, 5)
    const = 30
    if N < 2:
        return []
    if N <= const:
        pos = 0
        while __smallp[pos] <= N:
            pos += 1
        return list(__smallp[:pos])
    # make the offsets list
    offsets = (7, 11, 13, 17, 19, 23, 29, 1)
    # prepare the list
    p = [2, 3, 5]
    dim = 2 + N // const
    tk1 = [True] * dim
    tk7 = [True] * dim
    tk11 = [True] * dim
    tk13 = [True] * dim
    tk17 = [True] * dim
    tk19 = [True] * dim
    tk23 = [True] * dim
    tk29 = [True] * dim
    tk1[0] = False
    # help dictionary d
    # d[a , b] = c  ==> if I want to find the smallest useful multiple of (30*pos)+a
    # on tkc, then I need the index given by the product of [(30*pos)+a][(30*pos)+b]
    # in general. If b < a, I need [(30*pos)+a][(30*(pos+1))+b]
    d = {}
    for x in offsets:
        for y in offsets:
            res = (x * y) % const
            if res in offsets:
                d[(x, res)] = y
    # another help dictionary: gives tkx calling tmptk[x]
    tmptk = {1: tk1, 7: tk7, 11: tk11, 13: tk13, 17: tk17, 19: tk19, 23: tk23, 29: tk29}
    pos, prime, lastadded, stop = 0, 0, 0, int(ceil(sqrt(N)))

    # inner functions definition
    def del_mult(tk, start, step):
        for k in range(start, len(tk), step):
            tk[k] = False

    # end of inner functions definition
    cpos = const * pos
    while prime < stop:
        # 30k + 7
        if tk7[pos]:
            prime = cpos + 7
            p.append(prime)
            lastadded = 7
            for off in offsets:
                tmp = d[(7, off)]
                start = (
                    (pos + prime)
                    if off == 7
                    else (prime * (const * (pos + 1 if tmp < 7 else 0) + tmp)) // const
                )
                del_mult(tmptk[off], start, prime)
        # 30k + 11
        if tk11[pos]:
            prime = cpos + 11
            p.append(prime)
            lastadded = 11
            for off in offsets:
                tmp = d[(11, off)]
                start = (
                    (pos + prime)
                    if off == 11
                    else (prime * (const * (pos + 1 if tmp < 11 else 0) + tmp)) // const
                )
                del_mult(tmptk[off], start, prime)
        # 30k + 13
        if tk13[pos]:
            prime = cpos + 13
            p.append(prime)
            lastadded = 13
            for off in offsets:
                tmp = d[(13, off)]
                start = (
                    (pos + prime)
                    if off == 13
                    else (prime * (const * (pos + 1 if tmp < 13 else 0) + tmp)) // const
                )
                del_mult(tmptk[off], start, prime)
        # 30k + 17
        if tk17[pos]:
            prime = cpos + 17
            p.append(prime)
            lastadded = 17
            for off in offsets:
                tmp = d[(17, off)]
                start = (
                    (pos + prime)
                    if off == 17
                    else (prime * (const * (pos + 1 if tmp < 17 else 0) + tmp)) // const
                )
                del_mult(tmptk[off], start, prime)
        # 30k + 19
        if tk19[pos]:
            prime = cpos + 19
            p.append(prime)
            lastadded = 19
            for off in offsets:
                tmp = d[(19, off)]
                start = (
                    (pos + prime)
                    if off == 19
                    else (prime * (const * (pos + 1 if tmp < 19 else 0) + tmp)) // const
                )
                del_mult(tmptk[off], start, prime)
        # 30k + 23
        if tk23[pos]:
            prime = cpos + 23
            p.append(prime)
            lastadded = 23
            for off in offsets:
                tmp = d[(23, off)]
                start = (
                    (pos + prime)
                    if off == 23
                    else (prime * (const * (pos + 1 if tmp < 23 else 0) + tmp)) // const
                )
                del_mult(tmptk[off], start, prime)
        # 30k + 29
        if tk29[pos]:
            prime = cpos + 29
            p.append(prime)
            lastadded = 29
            for off in offsets:
                tmp = d[(29, off)]
                start = (
                    (pos + prime)
                    if off == 29
                    else (prime * (const * (pos + 1 if tmp < 29 else 0) + tmp)) // const
                )
                del_mult(tmptk[off], start, prime)
        # now we go back to top tk1, so we need to increase pos by 1
        pos += 1
        cpos = const * pos
        # 30k + 1
        if tk1[pos]:
            prime = cpos + 1
            p.append(prime)
            lastadded = 1
            for off in offsets:
                tmp = d[(1, off)]
                start = (
                    (pos + prime)
                    if off == 1
                    else (prime * (const * pos + tmp)) // const
                )
                del_mult(tmptk[off], start, prime)
    # time to add remaining primes
    # if lastadded == 1, remove last element and start adding them from tk1
    # this way we don't need an "if" within the last while
    if lastadded == 1:
        p.pop()
    # now complete for every other possible prime
    while pos < len(tk1):
        cpos = const * pos
        if tk1[pos]:
            p.append(cpos + 1)
        if tk7[pos]:
            p.append(cpos + 7)
        if tk11[pos]:
            p.append(cpos + 11)
        if tk13[pos]:
            p.append(cpos + 13)
        if tk17[pos]:
            p.append(cpos + 17)
        if tk19[pos]:
            p.append(cpos + 19)
        if tk23[pos]:
            p.append(cpos + 23)
        if tk29[pos]:
            p.append(cpos + 29)
        pos += 1
    # remove exceeding if present
    pos = len(p) - 1
    while p[pos] > N:
        pos -= 1
    if pos < len(p) - 1:
        del p[pos + 1 :]
    # return p list
    return p


def sieve_of_eratosthenes(n):
    """sieveOfEratosthenes(n): return the list of the primes < n."""
    # Code from: <dickinsm@gmail.com>, Nov 30 2006
    # http://groups.google.com/group/comp.lang.python/msg/f1f10ced88c68c2d
    if n <= 2:
        return []
    sieve = list(range(3, n, 2))
    top = len(sieve)
    for si in sieve:
        if si:
            bottom = (si * si - 3) // 2
            if bottom >= top:
                break
            sieve[bottom::si] = [0] * -((bottom - top) // si)
    return [2] + [el for el in sieve if el]


def sieve_of_atkin(end):
    """return a list of all the prime numbers <end using the Sieve of Atkin."""
    # Code by Steve Krenzel, <Sgk284@gmail.com>, improved
    # Code: https://web.archive.org/web/20080324064651/http://krenzel.info/?p=83
    # Info: http://en.wikipedia.org/wiki/Sieve_of_Atkin
    assert end > 0
    lng = (end - 1) // 2
    sieve = [False] * (lng + 1)

    x_max, x2, xd = int(sqrt((end - 1) / 4.0)), 0, 4
    for xd in range(4, 8 * x_max + 2, 8):
        x2 += xd
        y_max = int(sqrt(end - x2))
        n, n_diff = x2 + y_max * y_max, (y_max << 1) - 1
        if not (n & 1):
            n -= n_diff
            n_diff -= 2
        for d in range((n_diff - 1) << 1, -1, -8):
            m = n % 12
            if m == 1 or m == 5:
                m = n >> 1
                sieve[m] = not sieve[m]
            n -= d

    x_max, x2, xd = int(sqrt((end - 1) / 3.0)), 0, 3
    for xd in range(3, 6 * x_max + 2, 6):
        x2 += xd
        y_max = int(sqrt(end - x2))
        n, n_diff = x2 + y_max * y_max, (y_max << 1) - 1
        if not (n & 1):
            n -= n_diff
            n_diff -= 2
        for d in range((n_diff - 1) << 1, -1, -8):
            if n % 12 == 7:
                m = n >> 1
                sieve[m] = not sieve[m]
            n -= d

    x_max, y_min, x2, xd = int((2 + sqrt(4 - 8 * (1 - end))) / 4), -1, 0, 3
    for x in range(1, x_max + 1):
        x2 += xd
        xd += 6
        if x2 >= end:
            y_min = (((int(ceil(sqrt(x2 - end))) - 1) << 1) - 2) << 1
        n, n_diff = ((x * x + x) << 1) - 1, (((x - 1) << 1) - 2) << 1
        for d in range(n_diff, y_min, -8):
            if n % 12 == 11:
                m = n >> 1
                sieve[m] = not sieve[m]
            n += d

    primes = [2, 3]
    if end <= 3:
        return primes[: max(0, end - 2)]

    for n in range(5 >> 1, (int(sqrt(end)) + 1) >> 1):
        if sieve[n]:
            primes.append((n << 1) + 1)
            aux = (n << 1) + 1
            aux *= aux
            for k in range(aux, end, 2 * aux):
                sieve[k >> 1] = False

    s = int(sqrt(end)) + 1
    if s % 2 == 0:
        s += 1
    primes.extend([i for i in range(s, end, 2) if sieve[i >> 1]])

    return primes


def ambi_sieve_plain(n):
    s = list(range(3, n, 2))
    for m in range(3, int(n ** 0.5) + 1, 2):
        if s[(m - 3) // 2]:
            for t in range((m * m - 3) // 2, (n >> 1) - 1, m):
                s[t] = 0
    return [2] + [t for t in s if t > 0]


def sundaram3(max_n):
    # /programming/2068372/fastest-way-to-list-all-primes-below-n-in-python/2073279#2073279
    numbers = range(3, max_n + 1, 2)
    half = (max_n) // 2
    initial = 4

    for step in range(3, max_n + 1, 2):
        for i in range(initial, half, step):
            numbers[i - 1] = 0
        initial += 2 * (step + 1)

        if initial > half:
            return [2] + filter(None, numbers)


# Using Numpy:
def ambi_sieve(n):
    # http://tommih.blogspot.com/2009/04/fast-prime-number-generator.html
    s = np.arange(3, n, 2)
    for m in range(3, int(n ** 0.5) + 1, 2):
        if s[(m - 3) // 2]:
            s[(m * m - 3) // 2::m] = 0
    return np.r_[2, s[s > 0]]


def primesfrom3to(n):
    # /programming/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    """ Returns an array of primes, p < n """
    assert n >= 2
    sieve = np.ones(n // 2, dtype=np.bool)
    for i in range(3, int(n ** 0.5) + 1, 2):
        if sieve[i // 2]:
            sieve[i * i // 2::i] = False
    return np.r_[2, 2 * np.nonzero(sieve)[0][1::] + 1]


def primesfrom2to(n):
    # /programming/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    """ Input n>=6, Returns an array of primes, 2 <= p < n """
    assert n >= 6
    sieve = np.ones(n // 3 + (n % 6 == 2), dtype=np.bool)
    sieve[0] = False
    for i in range(int(n ** 0.5) // 3 + 1):
        if sieve[i]:
            k = 3 * i + 1 | 1
            sieve[((k * k) // 3)::2 * k] = False
            sieve[(k * k + 4 * k - 2 * k * (i & 1)) // 3::2 * k] = False
    return np.r_[2, 3, ((3 * np.nonzero(sieve)[0] + 1) | 1)]


def sympy_sieve(n):
    return list(sympy.sieve.primerange(1, n))


perfplot.save(
    "prime.png",
    setup=lambda n: n,
    kernels=[
        rwh_primes,
        rwh_primes1,
        rwh_primes2,
        sieve_wheel_30,
        sieve_of_eratosthenes,
        sieve_of_atkin,
        # ambi_sieve_plain,
        # sundaram3,
        ambi_sieve,
        primesfrom3to,
        primesfrom2to,
        sympy_sieve,
    ],
    n_range=[2 ** k for k in range(3, 25)],
    logx=True,
    logy=True,
    xlabel="n",
)

0

Dugaan saya adalah bahwa yang tercepat dari semua cara adalah dengan mengkodekan bilangan prima dalam kode Anda.

Jadi mengapa tidak hanya menulis skrip lambat yang menghasilkan file sumber lain yang memiliki semua angka yang tertanam di dalamnya, dan kemudian mengimpor file sumber itu ketika Anda menjalankan program Anda yang sebenarnya.

Tentu saja, ini bekerja hanya jika Anda tahu batas atas N pada waktu kompilasi, tetapi demikian halnya untuk (hampir) semua masalah Euler proyek.

 

PS: Saya mungkin salah meskipun jika menguraikan sumber dengan bilangan prima terprogram lebih lambat daripada menghitungnya, tetapi sejauh yang saya tahu Python menjalankan dari .pycfile yang dikompilasi sehingga membaca array biner dengan semua bilangan prima hingga N harus berdarah cepat dalam hal itu.


0

Maaf mengganggu tapi erat2 () memiliki kesalahan serius dalam algoritma.

Saat mencari komposit berikutnya, kita perlu menguji angka ganjil saja. q, p keduanya aneh; maka q + p adalah genap dan tidak perlu diuji, tetapi q + 2 * p selalu aneh. Ini menghilangkan tes "jika genap" dalam kondisi loop sementara dan menyimpan sekitar 30% dari runtime.

Sementara kita melakukannya: alih-alih elegan 'D.pop (q, None)' dapatkan dan hapus metode gunakan 'jika q dalam D: p = D [q], del D [q]' yang dua kali lebih cepat ! Setidaknya di mesin saya (P3-1Ghz). Jadi saya sarankan implementasi algoritma pintar ini:

def erat3( ):
    from itertools import islice, count

    # q is the running integer that's checked for primeness.
    # yield 2 and no other even number thereafter
    yield 2
    D = {}
    # no need to mark D[4] as we will test odd numbers only
    for q in islice(count(3),0,None,2):
        if q in D:                  #  is composite
            p = D[q]
            del D[q]
            # q is composite. p=D[q] is the first prime that
            # divides it. Since we've reached q, we no longer
            # need it in the map, but we'll mark the next
            # multiple of its witnesses to prepare for larger
            # numbers.
            x = q + p+p        # next odd(!) multiple
            while x in D:      # skip composites
                x += p+p
            D[x] = p
        else:                  # is prime
            # q is a new prime.
            # Yield it and mark its first multiple that isn't
            # already marked in previous iterations.
            D[q*q] = q
            yield q

untuk penambahan bilangan prima yang tertunda ke dalam dikt (sampai kuadrat prime terlihat di input) lihat stackoverflow.com/a/10733621/849891 .
Will Ness

0

Metode tercepat yang saya coba sejauh ini didasarkan pada fungsi buku resep Pythonerat2 :

import itertools as it
def erat2a( ):
    D = {  }
    yield 2
    for q in it.islice(it.count(3), 0, None, 2):
        p = D.pop(q, None)
        if p is None:
            D[q*q] = q
            yield q
        else:
            x = q + 2*p
            while x in D:
                x += 2*p
            D[x] = p

Lihat jawaban ini untuk penjelasan tentang percepatan.


0

Saya mungkin terlambat ke pesta tetapi harus menambahkan kode saya sendiri untuk ini. Ini menggunakan sekitar n / 2 di ruang karena kita tidak perlu menyimpan angka genap dan saya juga menggunakan modul bitarray python, lebih jauh mengurangi konsumsi memori dan memungkinkan komputasi semua prima hingga 1.000.000.000

from bitarray import bitarray
def primes_to(n):
    size = n//2
    sieve = bitarray(size)
    sieve.setall(1)
    limit = int(n**0.5)
    for i in range(1,limit):
        if sieve[i]:
            val = 2*i+1
            sieve[(i+i*val)::val] = 0
    return [2] + [2*i+1 for i, v in enumerate(sieve) if v and i > 0]

python -m timeit -n10 -s "import euler" "euler.primes_to(1000000000)"
10 loops, best of 3: 46.5 sec per loop

Ini dijalankan pada 64bit 2.4GHZ MAC OSX 10.8.3


1
memposting satu waktu untuk mesin yang tidak dikenal tidak mengatakan apa-apa. Jawaban yang diterima di sini mengatakan "tanpa psyco, karena n = 1000000, rwh_primes2 adalah yang tercepat". Jadi, jika Anda memberikan timing Anda untuk kode itu serta kode Anda, pada mesin yang sama, dan pada 2, 4, 10 juta juga, maka itu akan jauh lebih informatif.
Will Ness

-1, Kode ini tergantung pada fitur-fitur khusus dari bitarray yang diimplementasikan dalam C, itulah sebabnya kode ini cepat karena sebagian besar pekerjaan sedang dilakukan dalam kode asli dalam tugas irisan. Paket BitArray BREAKS definisi standar untuk irisan yang tepat (diindeks selama rentang a) untuk urutan bisa berubah dalam yang memungkinkan menetapkan boolean tunggal 0/1 atau Benar / Salah ke seluruh elemen slice, sedangkan perilaku standar untuk murni Python tampaknya adalah untuk tidak mengizinkan ini dan hanya mengizinkan nilai penugasan 0 dalam hal ini diperlakukan sebagai del dari semua elemen slice dari urutan / array.
GordonBGood

cont'd: Jika memanggil kode asli non-standar harus dibandingkan, kita mungkin juga menulis paket generator urutan "fastprimes" berdasarkan kode C seperti yang dari Kim Priischieve prima dan menghasilkan semua primes dalam empat miliar ditambah 32 Kisaran nomor-bit hanya dalam beberapa detik dengan satu panggilan ke generator urutan. Ini juga akan menggunakan hampir tidak ada memori karena kode tertaut didasarkan pada Saringan Eratosthenes yang tersegmentasi dan dengan demikian hanya menggunakan beberapa kilobyte RAM, dan jika urutan dibuat tidak akan ada penyimpanan daftar yang diperlukan.
GordonBGood

0

Saya mengumpulkan beberapa saringan bilangan prima dari waktu ke waktu. Yang tercepat di komputer saya adalah ini:

from time import time
# 175 ms for all the primes up to the value 10**6
def primes_sieve(limit):
    a = [True] * limit
    a[0] = a[1] = False
    #a[2] = True
    for n in xrange(4, limit, 2):
        a[n] = False
    root_limit = int(limit**.5)+1
    for i in xrange(3,root_limit):
        if a[i]:
            for n in xrange(i*i, limit, 2*i):
                a[n] = False
    return a

LIMIT = 10**6
s=time()
primes = primes_sieve(LIMIT)
print time()-s

0

Saya lambat menanggapi pertanyaan ini tetapi sepertinya latihan yang menyenangkan. Saya menggunakan numpy yang mungkin curang dan saya ragu metode ini adalah yang tercepat tetapi harus jelas. Ini menyaring array Boolean mengacu hanya pada indeksnya dan memunculkan bilangan prima dari indeks semua nilai True. Tidak perlu modulo.

import numpy as np
def ajs_primes3a(upto):
    mat = np.ones((upto), dtype=bool)
    mat[0] = False
    mat[1] = False
    mat[4::2] = False
    for idx in range(3, int(upto ** 0.5)+1, 2):
        mat[idx*2::idx] = False
    return np.where(mat == True)[0]

itu salah mis., ajs_primes3a(10)-> array([2, 3, 5, 7, 9]). 9bukan prime
jfs

Anda melihat kasing tepi yang belum - bagus! Masalahnya adalah 'untuk idx dalam rentang (3, int (hingga ** 0.5), 2):' yang seharusnya 'untuk idx dalam kisaran (3, int (hingga ** 0.5) + 1, 2):'. Terima kasih tetapi itu berfungsi sekarang.
Alan James Salmoni

Alasannya adalah bahwa loop idx naik ke 'hingga ** 05' yang untuk kasus hingga dan termasuk 15. Dari 16 dan seterusnya, itu berfungsi dengan baik. Ini adalah serangkaian kasus tepi yang belum saya uji. Menambahkan 1 berarti itu harus bekerja untuk semua angka.
Alan James Salmoni

Tampaknya berfungsi sekarang. Ini adalah yang paling lambat di antara numpysolusi berbasis yang mengembalikan array. Catatan: tidak benar implementasi Saringan Eratosthenes menggunakan modulo - tidak perlu menyebutkannya. Anda bisa menggunakan mat[idx*idx::idx]bukan mat[idx*2::idx]. Dan np.nonzero(mat)[0]bukannya np.where(mat == True)[0].
jfs

Terima kasih JF. Saya menguji terhadap prime6 () dan mendapat hasil lebih cepat hingga (IIRC) sekitar 250k ketika prime6 () mengambil alih. primesfrom2to () lebih cepat. Hingga 20m, ajs_primes3a () mengambil 0,034744977951ms, prime6 () mengambil 0,0222899913788ms dan primesfrom2to () mengambil 0,0104751586914ms (mesin yang sama, beban yang sama, terbaik dari 10 timing). Jujur itu lebih baik daripada yang saya kira!
Alan James Salmoni

0

Berikut adalah teknik yang menarik untuk menghasilkan bilangan prima (namun bukan yang paling efisien) menggunakan pemahaman daftar python:

noprimes = [j for i in range(2, 8) for j in range(i*2, 50, i)]
primes = [x for x in range(2, 50) if x not in noprimes]

Anda dapat menemukan contoh dan beberapa penjelasan di sini

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.