Swift 我该怎么办？敏捷的 func步骤（g:Int，m:Int，n:Int）->（Int，Int）？{ var z=[m] var x=m 变量y=n 而x[1,2,3,4,5] 对于数组中的元素{ if！isPrime（n:element）{//检查for循环中的numberis prime array.remove（at:array.index（of:element）！）//如果不是，则删除 } } 返回数组 } someFunc（x:a，y:b）//这就是你如何称呼这个func的。someFunc（x:4，y:8）--->[5，7] //这是一个查找素数的支持函数。。非常直截了当，在下面的源代码链接中解释。 func isPrime（n:Int）->Bool{ 如果n

因此，它当前以数组的形式返回一组数字100-130。整体函数的作用比我要问的要大，但现在我只想创建一个数组，它接受数字100-130，或者更具体地说是数字x-y，并返回一个素数数组。if i%k部分需要帮助。是的，我知道这是多余的和拉长，但我在这方面是新的。也就是说，尽量只使用简单的快捷方式。 尽管如此，我也可以举一些例子来说明如何提高效率，但我需要一些解释，因为。。嗯，我是新来的。对于上下文，假设您只做了20-30天（一般编码）

您可以这样做：

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

设a=102
设b=576//两个您要在其中检查的数字
/****此函数用于返回素数数组****/
func someFunc（x:Int，y:Int）->[Int]{
var array=array（x…y）//这是一种从范围映射和创建数组的快速方法。///数组（1…5）。-->[1,2,3,4,5]
对于数组中的元素{
if！isPrime（n:element）{//检查for循环中的numberis prime
array.remove（at:array.index（of:element）！）//如果不是，则删除
}
}
返回数组
}
someFunc（x:a，y:b）//这就是你如何称呼这个func的。someFunc（x:4，y:8）--->[5，7]
//这是一个查找素数的支持函数。。非常直截了当，在下面的源代码链接中解释。
func isPrime（n:Int）->Bool{
如果n首先，最好尽可能将逻辑分离为函数。例如，这里有一个通用函数，用于计算一个数是否为素数（改编自）：

为了进行解释，
stride
将返回要单步执行的数字的
序列
，然后您可以
过滤
，以便在传递到函数
isPrime
时仅获取返回的数字

顺便说一下，您的
print示例（步骤（2100130））
应该不打印任何内容，因为您将检查100到130之间的所有偶数，这显然是非素数

我还建议您不要使用单字母变量名。
g
、
m
、
n
和
z
都不是描述性的。您希望简洁明了，以便其他人能够理解您的代码。
这将返回两个数字之间的素数数组：

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

如果您想在高于
1的差异中采取步骤，这里有另一个函数

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
}

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

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
}

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
        }