エラトステネスのふるい-素数を見つけるPython
明確にするために、これは宿題の問題ではありません:)
私が構築している数学アプリケーションの素数を見つけたいと思いました Serof of Eratosthenes アプローチ。
Pythonで実装を作成しました。しかし、それはものすごく遅いです。たとえば、200万未満の素数をすべて検索する場合。 20分以上かかります。 （この時点で停止しました）。これをどのようにスピードアップできますか？
def primes_sieve(limit):
limitn = limit+1
primes = range(2, limitn)
for i in primes:
factors = range(i, limitn, i)
for f in factors[1:]:
if f in primes:
primes.remove(f)
return primes
print primes_sieve(2000)
UPDATE：このコードでプロファイリングを行った結果、リストから要素を削除するのにかなりの時間がかかっていることがわかりました。要素を見つけてそれを削除し、リストを再調整するためにリスト全体（最悪の場合）を走査する必要があることを考えると、かなり理解しやすいでしょう（おそらくコピーが続くのでしょうか？）。とにかく、辞書のリストを取り出しました。私の新しい実装-
def primes_sieve1(limit):
limitn = limit+1
primes = dict()
for i in range(2, limitn): primes[i] = True
for i in primes:
factors = range(i,limitn, i)
for f in factors[1:]:
primes[f] = False
return [i for i in primes if primes[i]==True]
print primes_sieve1(2000000)
正しいアルゴリズムを実装していません：
最初の例では、primes_sieveは（アルゴリズムのように）ストライキ/アンセットするための素数フラグのリストを保持しませんが、代わりに整数のリストのサイズを連続的に変更します。これは非常に高価です。 。
2番目の例では、primes_sieve1は、原始フラグの辞書を維持します。これは正しい方向へのステップですが、未定義の順序で辞書を反復処理し、（素数の因子だけでなく、アルゴリズムのように）。キーをソートし、非プリムをスキップすることでこれを修正できます（既に1桁速くなっています）が、リストを直接使用する方がはるかに効率的です。
正しいアルゴリズム（辞書の代わりにリストを使用）は次のようになります。
def primes_sieve2(limit):
a = [True] * limit # Initialize the primality list
a[0] = a[1] = False
for (i, isprime) in enumerate(a):
if isprime:
yield i
for n in range(i*i, limit, i): # Mark factors non-prime
a[n] = False
（これには、素数の正方形（i*i）ダブルの代わりに。）
def eratosthenes(n):
multiples = []
for i in range(2, n+1):
if i not in multiples:
print (i)
for j in range(i*i, n+1, i):
multiples.append(j)
eratosthenes(100)
配列（リスト）の先頭から削除するには、それ以降のすべてのアイテムを移動する必要があります。つまり、この方法でリストのすべての要素を先頭から削除するのはO（n ^ 2）操作です。
セットでこれをより効率的に行うことができます。
def primes_sieve(limit):
limitn = limit+1
not_prime = set()
primes = []
for i in range(2, limitn):
if i in not_prime:
continue
for f in range(i*2, limitn, i):
not_prime.add(f)
primes.append(i)
return primes
print primes_sieve(1000000)
...または、リストを再配置する必要がないようにします。
def primes_sieve(limit):
limitn = limit+1
not_prime = [False] * limitn
primes = []
for i in range(2, limitn):
if not_prime[i]:
continue
for f in xrange(i*2, limitn, i):
not_prime[f] = True
primes.append(i)
return primes
はるかに高速：
import time
def get_primes(n):
m = n+1
#numbers = [True for i in range(m)]
numbers = [True] * m #EDIT: faster
for i in range(2, int(n**0.5 + 1)):
if numbers[i]:
for j in range(i*i, m, i):
numbers[j] = False
primes = []
for i in range(2, m):
if numbers[i]:
primes.append(i)
return primes
start = time.time()
primes = get_primes(10000)
print(time.time() - start)
print(get_primes(100))
多くの愛好家（上記のコメントのGlenn MaynardとMrHIDEnを含む）からの貢献を組み合わせることで、python 2：
def simpleSieve(sieveSize):
#creating Sieve.
sieve = [True] * (sieveSize+1)
# 0 and 1 are not considered prime.
sieve[0] = False
sieve[1] = False
for i in xrange(2,int(math.sqrt(sieveSize))+1):
if sieve[i] == False:
continue
for pointer in xrange(i**2, sieveSize+1, i):
sieve[pointer] = False
# Sieve is left with prime numbers == True
primes = []
for i in xrange(sieveSize+1):
if sieve[i] == True:
primes.append(i)
return primes
sieveSize = input()
primes = simpleSieve(sieveSize)
10の累乗のさまざまな入力に対してマシンで計算にかかる時間は次のとおりです。
- 3：0.3 ms
- 4：2.4ミリ秒
- 5：23ミリ秒
- 6：0.26秒
- 7：3.1秒
- 8：33秒
私はこれが素数を素早く生成する方法の質問に実際に答えていないことを理解していますが、おそらくこの代替案が興味深いと思う人もいるでしょう：pythonはジェネレータを介して遅延評価を提供するため、述べたように：
def intsfrom(n):
while True:
yield n
n += 1
def sieve(ilist):
p = next(ilist)
yield p
for q in sieve(n for n in ilist if n%p != 0):
yield q
try:
for p in sieve(intsfrom(2)):
print p,
print ''
except RuntimeError as e:
print e
Tryブロックが存在するのは、スタックを爆破するまでアルゴリズムが実行されるためです。tryブロックがないと、バックトレースが表示され、画面から見たい実際の出力がプッシュされます。
ループの終了条件として単純に空のリストを使用することが可能でなければならないと考え、これを思いつきました：
limit = 100
ints = list(range(2, limit)) # Will end up empty
while len(ints) > 0:
prime = ints[0]
print prime
ints.remove(prime)
i = 2
multiple = prime * i
while multiple <= limit:
if multiple in ints:
ints.remove(multiple)
i += 1
multiple = prime * i
私は速度のためにNumPyを好みます。
import numpy as np
# Find all prime numbers using Sieve of Eratosthenes
def get_primes1(n):
m = int(np.sqrt(n))
is_prime = np.ones(n, dtype=bool)
is_prime[:2] = False # 0 and 1 are not primes
for i in range(2, m):
if is_prime[i] == False:
continue
is_prime[i*i::i] = False
return np.nonzero(is_prime)[0]
# Find all prime numbers using brute-force.
def isprime(n):
''' Check if integer n is a prime '''
n = abs(int(n)) # n is a positive integer
if n < 2: # 0 and 1 are not primes
return False
if n == 2: # 2 is the only even prime number
return True
if not n & 1: # all other even numbers are not primes
return False
# Range starts with 3 and only needs to go up the square root
# of n for all odd numbers
for x in range(3, int(n**0.5)+1, 2):
if n % x == 0:
return False
return True
# To apply a function to a numpy array, one have to vectorize the function
def get_primes2(n):
vectorized_isprime = np.vectorize(isprime)
a = np.arange(n)
return a[vectorized_isprime(a)]
出力を確認します。
n = 100
print(get_primes1(n))
print(get_primes2(n))
[ 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]
[ 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]
Jupyter NotebookのSieve of Eratosthenesとブルートフォースの速度を比較します。数百万の要素に対して、ブルートフォースよりも539倍速いエラトステネスのふるい。
%timeit get_primes1(1000000)
%timeit get_primes2(1000000)
4.79 ms ± 90.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
2.58 s ± 31.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
これはエラトステネス法で素数を見つけるための最短のコードだと思います
def prime(r):
n = range(2,r)
while len(n)>0:
yield n[0]
n = [x for x in n if x not in range(n[0],r,n[0])]
print(list(prime(r)))
私の最速の実装：
isprime = [True]*N
isprime[0] = isprime[1] = False
for i in range(4, N, 2):
isprime[i] = False
for i in range(3, N, 2):
if isprime[i]:
for j in range(i*i, N, 2*i):
isprime[j] = False
これは、もう少しメモリ効率の高いバージョンです（そして、試用区分ではなく適切なふるいです）。基本的に、すべての数値の配列を保持し、素数ではないものを消すのではなく、これはカウンターの配列を保持します-発見された各素数ごとに1つ-推定素数の前に跳躍します。そのようにして、最高の素数までではなく、素数の数に比例したストレージを使用します。
_import itertools
def primes():
class counter:
def __init__ (this, n): this.n, this.current, this.isVirgin = n, n*n, True
# isVirgin means it's never been incremented
def advancePast (this, n): # return true if the counter advanced
if this.current > n:
if this.isVirgin: raise StopIteration # if this is virgin, then so will be all the subsequent counters. Don't need to iterate further.
return False
this.current += this.n # pre: this.current == n; post: this.current > n.
this.isVirgin = False # when it's gone, it's gone
return True
yield 1
multiples = []
for n in itertools.count(2):
isPrime = True
for p in (m.advancePast(n) for m in multiples):
if p: isPrime = False
if isPrime:
yield n
multiples.append (counter (n))
_primes()はジェネレーターであるため、結果をリストに保持したり、直接使用したりできます。最初のnプライムは次のとおりです。
_import itertools
for k in itertools.islice (primes(), n):
print (k)
_そして、完全を期すために、パフォーマンスを測定するタイマーを以下に示します。
_import time
def timer ():
t, k = time.process_time(), 10
for p in primes():
if p>k:
print (time.process_time()-t, " to ", p, "\n")
k *= 10
if k>100000: return
_ご参考までに、primes()も簡単なイテレーター（___iter___および___next___を使用）として作成しましたが、ほぼ同じ速度で実行されました。私も驚いた！
私の実装：
import math
n = 100
marked = {}
for i in range(2, int(math.sqrt(n))):
if not marked.get(i):
for x in range(i * i, n, i):
marked[x] = True
for i in range(2, n):
if not marked.get(i):
print i
単純なスピードハック：変数「primes」を定義するとき、すべての偶数を自動的にスキップするようにステップを2に設定し、開始点を1に設定します。
その後、素数のiの代わりに、素数のiに使用してさらに最適化できます[：round（len（primes）** 0.5）]。これにより、パフォーマンスが劇的に向上します。さらに、5で終わる数字を削除して、速度をさらに上げることができます。
import math
def sieve(n):
primes = [True]*n
primes[0] = False
primes[1] = False
for i in range(2,int(math.sqrt(n))+1):
j = i*i
while j < n:
primes[j] = False
j = j+i
return [x for x in range(n) if primes[x] == True]