統計所有小於非負整數n的質數的數量。

示例 1：

輸入：n = 10
輸出：4
解釋：小於 10 的質數一共有 4 個, 它們是 2, 3, 5, 7 。

示例 2：

輸入：n = 0
輸出：0

示例 3：

輸入：n = 1
輸出：0

提示：

0 <= n <= 5 * 106

思路一：質數，只能被1和本身整除。

    //求n以內的質數
    func countPrimes1(_ n: Int) -> Int {
        if n < 3 {
            return 0
        }
        if n == 3 {
            
 
return 1
        }
        var array:[Int] = [2]
        for i in 3 ... n - 1 {
            //預設是質數
            var flag = true
            for j in 2 ... i - 1 {
                if i % j == 0 {
                    //能整除就是合數
                    flag = false
                    break
                }
            }
            
 
if flag == true {
                array.append(i)
            }
        }
        print(array)
        return array.count
    }

優化一：大於2的偶數肯定是合數，先過濾掉。然後除以2到i的平方根即可。

　　 //求n以內的質數
    func countPrimes4(_ n: Int) -> Int {
        if n < 3 {
            return 0
        }
        if n == 3 {
            
 
return 1
        }
        if n == 4 || n == 5 {
            return 2
        }
        
        var array:[Int] = [2,3]
        for i in 5 ... n - 1 {
            if i % 2 == 0 {
                //偶數肯定是合數
                continue
            }
            //預設是質數
            var flag = true
            //如果一個合數，那它除了1和他本身一定還有別的約數，假如這個數是num,num=m*n 一定可以分解為兩個整數相乘,設一個命題 ,num可以分解為兩個數相乘且這兩個數都大於num在平方根,ｍ>sqrt(num) n>sqrt(num) 根據數學知識可以知道ｍ*ｎ>ｎｕｍ 這與命題相反，所以命題是假的。所以合數一定至少有一個不大於sqrt(num)約數，只要找到這個數就可以了。
            let value = Int(sqrt(Double(i)))
            for j in 2 ... value {
                if j % 2 == 0 {
                    //偶數肯定是合數
                    continue
                }
                if i % j == 0 {
                    //能整除就是合數
                    flag = false
                    break
                }
            }
            if flag == true {
                array.append(i)
            }
        }
        return array.count
    }

思路二：效能很高

1. 厄拉多塞篩法
西元前250年，希臘數學家厄拉多塞(Eeatosthese)想到了一個非常美妙的質數篩法，減少了逐一檢查每個數的的步驟，可以比較簡單的從一大堆數字之中，篩選出質數來，這方法被稱作厄拉多塞篩法(Sieve of Eeatosthese)。

具體操作：先將 2~n 的各個數放入表中，然後在2的上面畫一個圓圈，劃去2的其他倍數；第一個既未畫圈又沒有被劃去的數是3，將它畫圈，劃去3的其他倍數；現在既未畫圈又沒有被劃去的第一個數 是 5，將它畫圈，並劃去5的其他倍數……依次類推，一直到所有小於或等於 n 的各數都畫了圈或劃去為止。這時，表中畫了圈的以及未劃去的那些數正好就是小於 n 的素數。

分析：整個過程就是不停的畫圈，最後沒有被圈住的就是我們要的質數

class Solution {
    func countPrimes(_ n: Int) -> Int {
        if n < 3 {
            return 0
        }
        var data = [Bool](repeating: true, count: n)
        var count = 0

        for i in 2..<n {
            if data[i] {
              var j = i*2
              while j<n {
                data[j] = false
                j+=i
              }
              count+=1
            }
        }
        return count
    }
}