在Go中生成素数

编辑：这个问题本质上是要求生成达到某个限制的素数。原来的问题如下

如果仅满足以下两个条件，我希望我的

if

语句变为true：

for i := 2; i <= 10; i++ {

    if i%i == 0 && i%1 == 0 {

    } else {

    }
}

---

i:=2的

；看来你在找我。但是，您描述的条件还不够。事实上，您必须使用算法来生成它们（最有可能达到某个限制）

其中一种是对古老的埃拉托斯坦筛的优化变化

演示：

为了完整起见：

package main

import (
    "fmt"
    "math"
)

// Only primes less than or equal to N will be generated
const N = 100

func main() {
    var x, y, n int
    nsqrt := math.Sqrt(N)

    is_prime := [N]bool{}

    for x = 1; float64(x) <= nsqrt; x++ {
        for y = 1; float64(y) <= nsqrt; y++ {
            n = 4*(x*x) + y*y
            if n <= N && (n%12 == 1 || n%12 == 5) {
                is_prime[n] = !is_prime[n]
            }
            n = 3*(x*x) + y*y
            if n <= N && n%12 == 7 {
                is_prime[n] = !is_prime[n]
            }
            n = 3*(x*x) - y*y
            if x > y && n <= N && n%12 == 11 {
                is_prime[n] = !is_prime[n]
            }
        }
    }

    for n = 5; float64(n) <= nsqrt; n++ {
        if is_prime[n] {
            for y = n * n; y < N; y += n * n {
                is_prime[y] = false
            }
        }
    }

    is_prime[2] = true
    is_prime[3] = true

    primes := make([]int, 0, 1270606)
    for x = 0; x < len(is_prime)-1; x++ {
        if is_prime[x] {
            primes = append(primes, x)
        }
    }

    // primes is now a slice that contains all primes numbers up to N
    // so let's print them
    for _, x := range primes {
        fmt.Println(x)
    }
}

主程序包
进口(
“fmt”
“数学”
)
//只生成小于或等于N的素数
常数N=100
func main（）{
变量x，y，n int
nsqrt:=math.Sqrt（N）
is_素数：=[N]bool{}
对于x=1；float64（x）获得“只能用自身和1整除的数”，也称为素数的最简单方法是：

这不是一个“简单的if语句”。
如果你不介意它们不是素数的可能性很小（本例中为9.1e-13），你可以这样使用（）

导入(
“fmt”
“数学/大”
)
func main（）{
对于i:=2；i<1000；i++{
如果是大的.NewInt（int64（i））.ProbablyPrime（20）{
fmt.Printf（“%d可能是素数，\n”，i）
}否则{
fmt.Printf（“%d绝对不是素数，\n”，i）
}
}
}

只需更改常量20，以确保它们是素数。
简单方法（固定）：

主程序包
导入“数学”
常数n=100
func main（）{
打印（1，“，2）
L:对于i:=3；i这是一个golang筛的埃拉托斯烯

package main
import "fmt"

// return list of primes less than N
func sieveOfEratosthenes(N int) (primes []int) {
    b := make([]bool, N)
    for i := 2; i < N; i++ {
        if b[i] == true { continue }
        primes = append(primes, i)
        for k := i * i; k < N; k += i {
            b[k] = true
        }
    }
    return
}

func main() {
    primes := sieveOfEratosthenes(100)
    for _, p := range primes {
        fmt.Println(p)
    }
}

主程序包
输入“fmt”
//返回小于N的素数列表
func-sieveoferatostenes（N int）（素数[]int）{
b:=制造（[]布尔，N）
对于i:=2；i
只需将外部for循环中的100更改为要查找的素数的限制。干杯

    for i:=2; i<=100; i++{


        isPrime:=true

        for j:=2; j<i; j++{

            if i % j == 0 {

                isPrime = false
            }
        }

        if isPrime == true {

            fmt.Println(i)
        } 
    }


}

对于i:=2；i在这里，通过检查所有角落案例和优化方法来尝试查找数字，并在函数返回true时运行逻辑

package main

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

func prime(n int) bool {

    if n < 1 {
        return false
    }

    if n == 2 {
        return true
    }

    if n % 2 == 0 && n > 2 {
        return false
    }

    var maxDivisor = int(math.Floor(math.Sqrt(float64 (n))))

    //d := 3
    for d:=3 ;d <= 1 + maxDivisor; d += 2 {

        if n%d == 0 {
            return false
        }
    }
    return true
}
//======Test Function=====

func main() {
    // var t0 = time.Time{}
    var t0= time.Second
    for i := 1; i <= 1000; i++ {
        fmt.Println(prime(i))
    }
    var t1= time.Second
    println(t1 - t0)
}

主程序包
进口(
“数学”
“时间”
“fmt”
)
func素数（n int）bool{
如果n<1{
返回错误
}
如果n==2{
返回真值
}
如果n%2==0&&n>2{
返回错误
}
var maxdivisior=int（math.Floor（math.Sqrt（float64（n）））
//d:=3
对于d:=3；d
package main
进口(
“fmt”
)
func main（）{
//runtime.GOMAXPROCS（4）
ch:=制造（成交量）
去生成（ch）
为了{
素数：=A
C
like逻辑（老派）

主程序包
输入“fmt”
func main（）{
var num=1000
对于j:=2；j对于i:=2；i素数是一个只能被1和自身整除的正整数。例如：2，3，5，7，11，13，17。
什么是素数？
素数是一个不能用其他整数相乘的整数

素数（或素数）是大于1的自然数，它不是两个较小的自然数的乘积。大于1的非素数的自然数称为复合数。
使用语言程序检查数字是否为素数
你确定素数检查就是这样工作的吗？你的if语句可以翻译成“if true”。可能不是。但是，如果像我请求的那样的语句可能吗？它严格遵循条件吗？@albind您的if语句检查
I
是否可以被自身和
1
均匀整除。所有数字都是。因此，您的if语句不排除任何数字。是否可以排除除I和1之外的所有数字（在本例中）公平地说，这是最简单合理有效的方法，但是O（N^2）嵌套<代码>对于循环更简单。@ PATATOSWATER足够公平。但是我认为这相当于冒泡排序。由于它的简单性，它很容易记住，并导致人们只记住它，然后在多年后的生产中找到它，同时试图找出为什么简单的东西会永远执行。如果同事实现了快速排序，ally会感到不安，因为库的实现很好。花在快速排序或冒泡排序上的时间也同样浪费了。这真是太神奇了，感谢并为我的错误道歉uncunningness@Agis，我认为代码没有按预期工作。我得到了从0到24的所有整数。@siritinga有一个拼写错误。现已修复。我只是添加了素数to上次fmt.Println（x，primes）编辑：再次尝试你的编辑：现在效果很好1270606代表什么？他想生成素数，而不是检查素数。我可以知道为什么
k:=I*I
而不是
k:=I
？我明白了-所有的数字都以
I*x
的形式出现在[2，I-1]
已在前面的外部循环中标记，其中i=x
    for i:=2; i<=100; i++{


        isPrime:=true

        for j:=2; j<i; j++{

            if i % j == 0 {

                isPrime = false
            }
        }

        if isPrime == true {

            fmt.Println(i)
        } 
    }


}

package main

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

func prime(n int) bool {

    if n < 1 {
        return false
    }

    if n == 2 {
        return true
    }

    if n % 2 == 0 && n > 2 {
        return false
    }

    var maxDivisor = int(math.Floor(math.Sqrt(float64 (n))))

    //d := 3
    for d:=3 ;d <= 1 + maxDivisor; d += 2 {

        if n%d == 0 {
            return false
        }
    }
    return true
}
//======Test Function=====

func main() {
    // var t0 = time.Time{}
    var t0= time.Second
    for i := 1; i <= 1000; i++ {
        fmt.Println(prime(i))
    }
    var t1= time.Second
    println(t1 - t0)
}

package main

import (
    "fmt"
)

func main() {
    //runtime.GOMAXPROCS(4)

    ch := make(chan int)
    go generate(ch)
    for {
        prime := <-ch
        fmt.Println(prime)
        ch1 := make(chan int)
        go filter(ch, ch1, prime)
        ch = ch1
    }
}

func generate(ch chan int) {
    for i := 2; ; i++ {
        ch <- i
    }
}

func filter(in, out chan int, prime int) {
    for {
        i := <-in
        if i%prime != 0 {
            out <- i
        }
    }
}

package main
import "fmt"

func main() {
    var num = 1000
    for j := 2; j < num  ; j++ {
        var flag = 0
        for i := 2; i <= j/2  ; i++ {   
            if j % i == 0 {
                flag = 1
                break
            }
        }
        if flag == 0 {
            fmt.Println(j)
        }
    }

}