204. Count Primes - swift

描述：

计算小于非负数整数n的质数（素数）个数

什么是质数（素数）：

质数（prime number）又称素数，有无限个。质数定义为在大于1的自然数中，除了1和它本身以外不再有其他因数的数称为质数。

判断一个数是否是素数：

func isPrimes(_ n:Int) -> Bool {
    if n < 2 {
        return false
    }
    
    guard n > 3 else {
        return true
    }
    
    var isPrimes: Bool = true
    (2...Int(sqrt(Double(n)))).forEach{
        if n % $0 == 0 {
            isPrimes = false
            return
        }}
    return isPrimes
}

要点：判断一个数是否是素数，为什么除到其平方根就可以了?
因为如果一个数不是素数是合数，
那么一定可以由两个自然数相乘得到，
其中一个大于或等于它的平方根，一个小于或等于它的平方根。并且成对出现。

小于n的质数集合

方法1：最直接的办法，时间复杂度为：o(n^2)：

func getPrimes(_ n:Int) -> [Int] {
    guard n > 2 else {
        return []
    }
    
    return (2..

方法2：

func primes(n: Int) -> [Int] {
    guard n > 3 else {
        return Array((2.. 0 else {
            continue
        }
        let prime = numbers[i]
        for multiple in stride(from: 2 * prime - 2, to: n-2, by: prime) {
            numbers[multiple] = 0
        }
    }
    return numbers.filter{$0 > 0}
}

图解过程：

屏幕快照 2017-01-04 00.22.43.png

方法3：

func sieve(numbers: [Int]) -> [Int] {
    if numbers.isEmpty {
        return []
    }
    
    guard let first = numbers.first, let last = numbers.last, first <= Int(ceilf(Float(last) / 2)) else {
        return numbers
    }
    
    let p = numbers[0]
    return [p] + sieve(numbers: numbers[1.. 0})
}

图解过程:

屏幕快照 2017-01-04 00.24.53.png

小于n的质数的个数

根据小于n的质数集合中的方法2改造：

func countPrimes(_ n: Int) -> Int {
    if n < 2 {return 0}
    
    guard n > 3 else {
        return Array((2.. 0 else {
            continue
        }
        let prime = numbers[i]
        var j = 2
        while prime * j - 2 < n-2 {
            if numbers[prime * j - 2] != 0 {
                numbers[prime * j - 2] = 0
                count -= 1
            }
            j += 1
        }
    }
    return count
}