Question

编辑：这个问题基本上要求生成最高限额的素数。最初的问题如下。

如果只满足以下两个条件，我希望我的if语句成为现实：

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

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

    } else {

    }
}

在这种情况下，每个可能的数字都超过了这些条件，但是我只想要数字2,3,5,7,11 ...基本上只能用自身整除的数字和1来过去，除了是第一个'2'。我怎么能这样做？

由于

Answer 1

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

This is an implementation的Sieve of Atkin是古代 Eratosthenes筛子的优化变体。

演示：http://play.golang.org/p/XXiTIpRBAu

为了完整起见：

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)
    }
}

Answer 2

这是Eratosthenes的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)
    }
}

Answer 3

获取“只能用自身和1整除的数字”的最简单方法是：http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes

这不是“简单的陈述”。

Answer 4

如果你不介意很少有机会（在这种情况下为9.1e-13），你可以使用ProbablyPrime这样的math/big（play）

import (
    "fmt"
    "math/big"
)

func main() {
    for i := 2; i < 1000; i++ {
        if big.NewInt(int64(i)).ProbablyPrime(20) {
            fmt.Printf("%d is probably prime\n", i)
        } else {
            fmt.Printf("%d is definitely not prime\n", i)
        }
    }
}

只需将常数20更改为您喜欢的常数即可。

Answer 5

简单方法（固定）：

package main

import "math"

const n = 100

func main() {
    print(1, " ", 2)

L:  for i := 3; i <= n; i += 2 {
        m := int(math.Floor(math.Sqrt(float64(i))))
        for j := 2; j <= m; j++ {
            if i%j == 0 {
                continue L
            }
        }
        print(" ", i)
    }
}

Answer 6

只需将外部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)
        } 
    }


}

Answer 7

这里通过检查所有极端情况和优化方式来查找数字并在函数返回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)
}

Answer 8

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
        }
    }
}

Answer 9

C之类的逻辑（旧式），

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)
        }
    }

}

Answer 10

质数是一个只能被1和它本身整除的正整数。例如：2、3、5、7、11、13、17。 什么是质数？ 质数是不能用其他整数相乘得到的整数

质数（或质数）是大于 1 且不是两个较小自然数的乘积的自然数。大于1的非素数的自然数称为合数。 Go 语言程序检查数字是否为质数 https://www.golanguagehub.com/2021/01/primenumber.html

Answer 11

生成不超过某个限制的素数的简单解决方案：

func findNthPrime(number int) int {

    if number < 1{
        fmt.Println("Please provide positive number")
        return number
    }

    var primeCounter, nthPrimeNumber int

    for i:=2; primeCounter < number; i++{
        isPrime := true
        for j:=2; j <= int(math.Sqrt(float64(i))) && i != 2  ; j++{
            if i % j == 0{
                isPrime = false
            }
        }
        if isPrime{
            primeCounter++
            nthPrimeNumber = i
            fmt.Println(primeCounter, "th prime number is ", nthPrimeNumber)
        }
    }
    fmt.Println("Nth prime number is ", nthPrimeNumber)
    return nthPrimeNumber
}

在Go中生成素数

11 个答案: