我从这里去哪里？迅速

Question

func step(_ g: Int, _ m: Int, _ n: Int) -> (Int, Int)? {
    var z = [m]
    var x = m
    var y = n
    while x < y {
        x += 1
        z += [x]
    }
    for i in z {
        var k = 2
        while k < n {

        if i % k != 0 && i != k {

            }
            k += 1
        }

    }
    print(z)
    return (0, 0)
}
print (step(2, 100, 130))

所以它当前以数组的形式返回数字 100-130 的集合。整个函数将比我所要求的更多，但现在我只想创建一个数组，它接受数字 100-130，或者更具体地说是数字 x-y 并返回一个素数数组。 if i%k 部分需要帮助。是的，我知道它是多余的和拉长的，但我对此很陌生。话虽如此，请尝试仅使用简单的快捷方式。 话虽如此，我也可以通过一些示例来提高效率，但我需要对其中的一些进行解释，因为……嗯，我是新人。对于上下文假设只这样做了 20-30 天（一般编码）

Answer 1

你可以这样做：

let a = 102 
let b = 576 // two numbers you want  to check within

/**** This function returns your array of primes ****/
func someFunc(x: Int, y: Int) -> [Int] {
    var array = Array(x...y) // This is a quick way to map and create array from a range . /// Array(1...5) . ---> [1,2,3,4,5]

    for element in array {
        if !isPrime(n: element) { // check if numberis prime in a for loop
            array.remove(at: array.index(of: element)!) // remove if it isnt
        }
    }

    return array
}

someFunc(x: a, y: b) //this is how you call this func.  someFunc(x: 4, y: 8) ---> [5, 7]


// THis is a supporting function to find a prime number .. pretty straight forward, explanation in source link below.
func isPrime(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
}

来源：Check if a number is prime?

Answer 2

首先，在可能的情况下将逻辑分离为函数是一个好主意。例如。这是一个计算一个数是否为素数的通用函数（改编自this answer）：

func isPrime<T>(_ n: T) -> Bool where T: BinaryInteger {
    guard n > 1 else {
        return false
    }
    guard n > 3 else {
        return true
    }

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

为了逐步获取数字，Swift 提供了stride 函数。所以你的函数可以简化为：

func step(_ g: Int, _ m: Int, _ n: Int) -> (Int, Int)? {
    let z = stride(from: m, to: n, by: g).filter { isPrime($0) }
    print(z)
    return (0, 0)
}

解释一下，stride 将返回您想要单步执行的数字的 Sequence，然后您可以通过 filter 仅获取那些在传递给函数 isPrime 时返回 true 的数字。

顺便说一句，您的 print(step(2, 100, 130)) 示例应该什么都不打印，因为您将检查从 100 到 130 的所有偶数，这显然是非质数。

我还建议您不要使用单字母变量名称。 g、m、n 和 z 不是描述性的。您希望清晰而不是简洁，以便其他人能够理解您的代码。

Answer 3

这将返回两个数字之间的素数数组：

extension Int {
  func isPrime() -> Bool {
    if self <= 3 { return self == 2 || self == 3 }
    for i in 2...self/2 {
      if self % i == 0 {
        return false
      }
    }
    return true
  }
}

func getPrimes(from start: Int, to end: Int) -> [Int] {
  var primes = [Int]()
  let range = start > end ? end...start : start...end

  for number in range {
    if number.isPrime() { primes.append(number) }
  }

  return primes
}

在扩展中，您基本上循环遍历 2 和所选数字/2 之间的每个数字，以检查它是否可整，如果是则返回 false，否则将返回 true。

getPrimes() 基本上接受 2 个数字，如果起始数字高于结束数字，则它们会交换位置（故障保护）。然后你只需在扩展的帮助下检查数字是否为素数，如果它是素数，则将值附加到数组中。

func step(_ steps: Int, _ start: Int, _ end: Int) {
            var primes = [Int]()
            var number = start
            repeat {
                if number.isPrime() { primes.append(number) }
                number+=steps
            } while number <= end
        }

如果您想在高于1的差异中采取步骤，这是另一个功能