package main

import (
    "math"
    "fmt"
    "time"
)

// 根据素数定义判断
func isPrime1(num int) bool {
    temp := num - 1
    for i := 2; i <= temp; i++ {
        if num%i == 0 {
            return false
        }
    }
    return true

}

// 优化方法1
// 一个数若可以进行因数分解，那么分解时得到的两个数一定是一个小于等于sqrt(n)，一个大于等于sqrt(n)
func isPrime2(num int) bool {
    mid := int(math.Sqrt(float64(num)))
    for i := 2; i < mid; i++ {
        if num%i == 0 {
            return false
        }
    }
    return true
}

// 优化方法2
/*
首先看一个关于质数分布的规律：大于等于5的质数一定和6的倍数相邻。例如5和7，11和13,17和19等等；
证明：令x≥1，将大于等于5的自然数表示如下：
······ 6x-1，6x，6x+1，6x+2，6x+3，6x+4，6x+5，6(x+1），6(x+1)+1 ······
可以看到，不在6的倍数两侧，即6x两侧的数为6x+2，6x+3，6x+4，由于2(3x+1)，3(2x+1)，2(3x+2)，
所以它们一定不是素数，再除去6x本身，显然，素数要出现只可能出现在6x的相邻两侧。
这里要注意的一点是，在6的倍数相邻两侧并不是一定就是质数。
根据以上规律，判断质数可以6个为单元快进，即将方法循环中i++步长加大为6，加快判断速度
孪生素数自行研究
*/
func isPrime3(num int) bool {
    //两个较小数另外处理
    if 2 == num || 3 == num {
        return true
    }

    //不在6的倍数两侧的一定不是质数
    if num%6 != 1 && num%6 != 5 {
        return false
    }
    mid := int(math.Sqrt(float64(num)))
    // 在6的倍数两侧的也可能不是质数
    for i := 5; i <= mid; i += 6 {
        if num%i == 0 || num%(i+2) == 0 {
            return false
        }
    }

    //排除所有，剩余的是质数
    return true
}

func main() {
    // 测试数据范围
    testNum :=100000
    var start time.Time
    // 方式1测试
     start = time.Now()
    for i:=2;i<testNum;i++{
        if isPrime1(i) {
            //fmt.Printf("%d,",i)
        }
    }
    fmt.Println()
    fmt.Println("方式1：计算消耗时间："+time.Now().Sub(start).String())
    // 方式2测试
    start = time.Now()
    for i:=2;i<testNum;i++{
        if isPrime2(i) {
            //fmt.Printf("%d,",i)
        }
    }
    fmt.Println()
    fmt.Println("方式2：计算消耗时间："+time.Now().Sub(start).String())
    // 方式3测试
    start = time.Now()
    for i:=2;i<testNum;i++{
        if isPrime3(i) {
            //fmt.Printf("%d,",i)
        }
    }
    fmt.Println()
    fmt.Println("方式3：计算消耗时间："+time.Now().Sub(start).String())

}
性能测试结果：
方式1：计算消耗时间：5.4003089s

方式2：计算消耗时间：34.002ms

方式3：计算消耗时间：11.0006ms