From Gossip@caterpillar

Algorithm Gossip: Eratosthenes篩選求質數

說明

除了自身之外，無法被其它整數整除的數稱之為質數，要求質數很簡單，但如何快速的求出質數則一直是程式設計人員與數學家努力的課題，在這邊介紹一個著名的 Eratosthenes求質數方法。

解法

首先知道這個問題可以使用迴圈來求解，將一個指定的數除以所有小於它的數，若可以整除就不是質數，然而如何減少迴圈的檢查次數？如何求出小於N的所有質數？

首先假設要檢查的數是N好了，則事實上只要檢查至N的開根號就可以了，道理很簡單，假設A*B = N，如果A大於N的開根號，則事實上在小於A之前的檢查就可以先檢查到B這個數可以整除N。不過在程式中使用開根號會精確度的問題，所以可以使用 i*i <= N進行檢查，且執行更快。

再來假設有一個篩子存放1～N，例如：

2　3　4　5　6　7　8　9　10　11　12　13　14　15　16　17　18　19　20　21 ........ N

先將2的倍數篩去：

2　3　5　7　9　11　13　15　17　19　21 ........ N

再將3的倍數篩去：

2　3　5　7　11　13　17　19　........ N

再來將5的倍數篩去，再來將7的質數篩去，再來將11的倍數篩去........，如此進行到最後留下的數就都是質數，這就是Eratosthenes篩選方法（Eratosthenes Sieve Method）。

檢查的次數還可以再減少，事實上，只要檢查6n+1與6n+5就可以了，也就是直接跳過2與3的倍數，使得程式中的if的檢查動作可以減少。

實作：C Java Python Scala Ruby

#include <stdio.h> 
#include <stdlib.h> 

#define N 1000 

void createPrime(int* prime);

int main(void) { 
    int prime[N+1]; 
    createPrime(prime);
    
    int i;
    for(i = 2; i < N; i++) { 
        if(prime[i] == 1) { 
            printf("%4d%c", i, i % 6 ? ' ': '\n'); 
        } 
    } 
    printf("\n"); 

    return 0; 
} 

void createPrime(int* prime) {
    int i;
    for(i = 2; i <= N; i++) 
        prime[i] = 1; 
    for(i = 2; i*i <= N; i++) { 
        if(prime[i] == 1) { 
            int j;
            for(j = 2*i; j <= N; j++) { 
                if(j % i == 0) 
                    prime[j] = 0; 
            } 
        } 
    }     
}

Java

import java.util.*;

public class Prime {    
    public static List<Integer> findPrimes(int max) {
        int[] prime = new int[max+1]; 
        Arrays.fill(prime, 1);

        for(int i = 2; i*i <= max; i++) { 
            if(prime[i] == 1) { 
                for(int j = 2*i; j <= max; j++) { 
                    if(j % i == 0) 
                        prime[j] = 0; 
                } 
            } 
        } 

        List<Integer> list = new ArrayList<Integer>();
        for(int i = 2; i <= max; i++) { 
            if(prime[i] == 1) { 
                list.add(i); 
            } 
        }
        
        return list;
    }
    
    public static void main(String[] args) {
        for(Integer p : Prime.findPrimes(1000)) {
            System.out.print(p + " ");
        }
    }
}

Python

import math
def findPrimes(max):
    prime = [1] * max
    for i in range(2, int(math.sqrt(max))):
        if prime[i] == 1:
            for j in range(2 * i, max):
                if j % i == 0:
                    prime[j] = 0
    return [i for i in range(2, max) if prime[i] == 1]
                
primes = findPrimes(1000)
for i in range(len(primes)):
    print(primes[i], end=" ")

Scala

def findPrimes(max: Int) = {
    val prime = (for(i <- 0 to max) yield 1).toArray
    for(
        i <- 2 to Math.sqrt(max)
        if prime(i) == 1;
        j <- (2 * i) to max
        if j % i == 0
    ) prime(j) = 0
    for {
        i <- 2 to max
        if prime(i) == 1
    } yield i
}

findPrimes(1000) foreach(p => printf("%d ", p))

Ruby

class Range
    def comprehend(&block)
        return self if block.nil?
        self.collect(&block).compact
    end
end

def findPrimes(max)
    prime = Array.new(max, 1)
    2.upto(Math.sqrt(max).to_i - 1) { |i|
        if prime[i] == 1
            (2 * i).upto(max - 1) { |j|
                if j % i == 0
                    prime[j] = 0
                end
            }
        end
    }
    (2..max - 1).comprehend { |i| i if prime[i] == 1}
end

findPrimes(1000).each { |i|
    print i, " "
}