最快的Prime Checker

Question

我正在尝试创建一个可以检查数字是否为素数的应用。

有人可以帮我查一下这个号码吗？

我需要一个简单的答案，而不是非常先进的算法。我是编程新手。

Answer 1

以下是Swift 3中的功能解决方案：

func isPrime(_ number: Int) -> Bool {
    return number > 1 && !(2..<number).contains { number % $0 == 0 }
}

首先确保数字大于1，然后创建一个范围从2到数字（不包括数字）并检查数字是否不能被范围内的每个数字整除

Answer 2

最快的Prime Checker

Swift 4.2，Xcode 10.1

这个素数检查函数和扩展是最有效的，因为它只检查 $\tfrac{1}{2}\sqrt{n}$ 整数的可分性。

复杂性： $O(\tfrac{1}{2}\sqrt{n})$

解决方案：

func isPrime(_ n: Int) -> Bool {
    guard n >= 2     else { return false }
    guard n != 2     else { return true  }
    guard n % 2 != 0 else { return false }
    return !stride(from: 3, through: Int(sqrt(Double(n))), by: 2).contains { n % $0 == 0 }
}

<强>扩展：

extension Int {
    var isPrime: Bool {
        guard self >= 2     else { return false }
        guard self != 2     else { return true  }
        guard self % 2 != 0 else { return false }
        return !stride(from: 3, through: Int(sqrt(Double(self))), by: 2).contains { self % $0 == 0 }
    }
}

如何运作

此代码优于其他答案的好处是它不会检查冗余数字。此代码仅检查一半数字，直到所需数字的平方根。

Answer 3

Swift 2示例：

func is_prime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    if n <= 3 {
        return true
    }
    var i = 2
    while i*i <= n {
        if n % i == 0 {
            return false
        }
        i = i + 1
    }
    return true
}

Answer 4

由于我的声誉，我无法回复，但我发现 Wayne Ellery的方法很棒。但是如果可能的话，只需要一点点修复......

// that's Swift 3.1
import Foundation

func isPrime(_ number: Int) -> Bool {
    // right below
    if number == 2 || number == 3 { return true }
    let maxDivider = Int(sqrt(Double(number)))
    return number > 1 && !(2...maxDivider).contains { number % $0 == 0 }
}

所有值大于number的整数sqrt(number)的分频器都不是必需的。

Answer 5

func divides(a: Int, b: Int) -> Bool {
    return a % b == 0
}

func countDivisors(number: Int) -> Int {
    var cnt = 0
    for i in 1...number {
        if divides(a: number, b: i) {
            cnt+=1
        }
    }
    return cnt
}



func isPrime(number: Int) -> Bool {
    return countDivisors(number: number) == 2
}

isPrime(number: 7)

Answer 6

在 Swift 3 ：

func prime(_ number: Int) -> Bool {
    return (1...number).filter({number % $0 == 0}).count <= 2
}

Answer 7

一种简单的方法是检查所有因子，直到数字的平方根。这不是最有效的方法，但对于您可能会在iPhone应用程序中输入的大多数数字来说已经足够了。（有关更复杂的算法，请参阅https://en.wikipedia.org/wiki/Primality_test。）

function is_prime(n: int)
    if n <= 1
        return false

    if n <= 3
        return true

    i = 2
    while i*i <= n
        if n % i == 0
           return false
        i = i + 1
    return true

Answer 8

单线：

丢弃不会更快地进行灌注（由于懒惰的评估）。
缩小搜索除数的范围。

func isPrime(_ n: Int) -> Bool {
  return (2...Int(Double(n).squareRoot())).lazy.filter({ n % $0 == 0 }).first == nil
}

Answer 9

func checkPrimeOrNot(numberToCheck:Int)-> Bool{
    var isPrime : Bool = false
    if numberToCheck > 2  {
        for  n in 2...(numberToCheck - 1) {
            isPrime = (numberToCheck % n ) == 0  ? false : true
            if !isPrime{
                break
            }
        }
    } else {
        isPrime = numberToCheck == 1 ? true : false
        isPrime = numberToCheck == 0 ? false : true
    }
    return isPrime
}

您可以这样调用此函数

let primeNumber = checkPrimeOrNot（numberToCheck：23）

Answer 10

斯威夫特3：

let number = 16
var isPrime = true
if number == 1 {
    isPrime = false
}
var i = 2
while i < number {
    if number % i == 0 {
        isPrime = false
    }
    i += 1
}
print(isPrime)

Answer 11

我刚刚完成这个程序以学习语法Swift4。以下是我的结论：

import Foundation
import Darwin

var Timestamp: Double {
    return (NSDate().timeIntervalSince1970)
}

func checkPrime(number: Int) -> String {
    let num: Double = Double(number)
    let squareRoot: Double = Double(sqrt(num))
    let sqr: Int = Int(floor(squareRoot))
    var i: Int = 3
    while i <= sqr {
        if number % i == 0 {

            return "Too bad... \(number) is not a prime number, you can divide it by \(i) :/"
        }
        i += 2
    }

    return "You chose \(number) wisely. Definitely a prime number"
}

func isPrime(check: Int) -> String {
    switch check {
        case check where check <= 1 :
            return "Neither 1 nor numbers below are prime numbers."
        case 2 :
            return "Congratulations ! \(check) is the only even prime number !"
        case let check where check % 2 == 0 :
            return "There is only one even prime number, and it's definitely not \(check)..."
        default :
            return checkPrime(number: check)
    }
}

print("Please write Int to check if it's prime")
if let typed: String = readLine() {
    if let num: Int = Int(typed) {
        let start = Timestamp
        print(isPrime(check: num))
        print("calculated in \((Timestamp - start)*1000) milliseconds")
    } else {
        print("Please choose an integer between 0 and \(Int.max)")
    }
}

这里发生的事情非常简单，但它帮助我了解了一些我想和像我这样的新手分享的事情！

首先我找到了一个时间戳函数here来计算我的程序检查数字是否为素数的时间。这与素数无关，所以不要谈论它。

我的第一个大问题是获得用户的输入。在Swift中寻找相应的提示后，我意识到我总是得到一个String作为答案我发现this convenient way帮助我理解Swift中的类型以及如何从String获取Int。

所以这里是找到素数的核心：

首先，函数isPrime评估显而易见的我知道如果它低于或等于1，它就不是素数。我学到了非常奇怪的语法，我真的需要记录下来

switch check {
    case check where check <= 1
}

我知道2是唯一的偶数素数我知道其他所有偶数都是不素数（语法奇怪）

如果我通过了这个测试，那么我真的可以检查这个数字是否为素数：

我已经了解到，您不必评估3中的所有数字（记住，我们排除2和下面的数字）到潜在素数，原因有两个：

如果它是2的任意倍数的倍数，则它已被排除
如果不能将它与从3到它的平方根的任何整数相乘，那么它就是素数。（more infos here）

所以从这里我必须得到我的号码的平方根，我需要将我的号码从Int切换到Double。我需要将我的结果存入Int var，这样我就可以将它与我的递增数字 i （从3到sqrt）进行比较。

之后，我只需检查我的号码 i 是否等于0，在这种情况下，它不是素数。由于我已经消除了偶数，我可以将 i 每个循环增加2，所以我只检查奇数。

这是我在这里的第一次贡献所以我真的希望它会有所帮助。我很确定我的代码远非完美，所以不要犹豫纠正/改进它！

Answer 12

var isPrime : Bool = true
for num in stride(from: 2, to: 100, by: +1){
for index in stride(from: 2, to: num/2, by: +1){
        isPrime = true
    if (num%index == 0){
        isPrime = false
        break
    }
}
    if isPrime{
        print("\(num) is a Prime Number")
    }
}

Answer 13

检查我的解决方案：

private func numberIsPrime(_ number:Int) -> Bool{

   var i = 2

   while (i*i) <= number {
       if number % i == 0 { return false }
       i += 1
   }

   return true

}

Answer 14

实际最快版本

TL; DR避免使用sqrt，它非常慢。

确保此解决方案不如发布的更紧凑的解决方案那么漂亮，但是如果性能是关键，那么这个解决方案将胜过任何解决方案。

func isPrime(_ n: Int) -> Bool {
    guard n != 2 else { return true }
    guard n % 2 != 0 && n > 1 else { return false }

    var i = 3
    while i * i <= n {
        if (n % i) == 0 {
            return false
        }
        i += 2
    }

    return true
}

Answer 15

func FindPrime(number: Int) -> Bool {
    guard number >= 2 else { return false }

    for i in 2 ..< number {
        if number % i == 0 {
            return false
        }
    }

    return true
}

这个函数的问题在于它在计算上昂贵：16,777,259 是一个质数，所以这个解决方案将从 2 除以 16,777,258，发现它们都不起作用在决定这个数是素数之前。

2. 考虑一下：如果数 n 不是素数，则表示可以通过乘以 x 和 y 两个因子来达到。如果这两者数字大于 n 的平方根，则 x * y 将是大于 n，这是不可能的。所以，我们可以确定，在 x 或 y 中的至少一个小于或等于 n 的平方根。

func FindPrime(number: Int) -> Bool {
    guard number >= 2 else { return false }
    guard number != 2 else { return true }
    let max = Int(ceil(sqrt(Double(number))))

    for i in 2 ... max {
        if number % i == 0 {
            return false
        }
    }

    return true
}

Answer 16

func primeOrNot(input : Int){
    
    var flag : Bool = false;
    if (input > 2){
        for i in 2...input/2{
            if(input % i == 0){
                flag = true
                break;
            }
        }
    }else{
        flag = true
    }
    let result = (flag == false) ? "\(input) is prime!" : "\(input) is not prime!"
    debugPrint(result)
}

Answer 17

func isPrime(n : Int) -> Bool{
    var t = true
    if n <= 1 {
        print("Choose a number higher than one")
    } else {
        for y in 2...n {
            if y == n {
                t = true
                break
            } else if n % y == 0 {
                t = false
                break
            } else if n % y != 0 {
            }
        }
    }
    return t
}

print(isPrime(n: 51))
// This only answers for the number inputted, in this case "51"

Answer 18

素数的形式为6f±1，不包括2和3，其中f是任何整数

func isPrime(_ number: Int) -> Bool 
{

     if (number <= 1)
     {
        return false;
     }   

     // The check for the number 2 and 3
     if (number <= 3)
     {
        return true;
     }

     if (number%2 == 0 || number%3 == 0)
     {
        return false;
     }

     for var i in stride(from: 5, to: number/2, by: 6)
     {

        if (number%i == 0 || number%(i+2) == 0)
        {
           return false;
        }   
     }

     return true;
}

解决方案的时间复杂度：O（sqrt（n））

Answer 19

以下是一个简单的强力函数，用于确定数字是否为素数。它将目标数除以小于其自身的所有正整数（1除外）。如果任何除法的余数为零，那么显然目标数不是素数。如果没有找到这样的除数，那么这个数就是素数。

func isNumberPrime(_ number : Int) -> Bool{
    for n in 2..<number {
        if( number % n == 0){
            return false
        }
    }
    return true
}

Answer 20

只添加以下2-3行代码：

for i in 2..<number {
    if (number % i == 0) {
        print("\(number) is not prime.")
    }
}

检查一个数字是否为素数？

20 个答案:

最快的Prime Checker

Swift 4.2，Xcode 10.1

解决方案：

如何运作