Swift泛型函数（n选k）

Question

我试图使这个JavaScript代码在Swift：k_combinations

到目前为止，我在斯威夫特有这样的记录：

import Foundation
import Cocoa

extension Array {
func slice(args: Int...) -> Array {
    var s = args[0]
    var e = self.count - 1
    if args.count > 1 { e = args[1] }

    if e < 0 {
        e += self.count
    }

    if s < 0 {
        s += self.count
    }

    let count = (s < e ? e-s : s-e)+1
    let inc = s < e ? 1 : -1
    var ret = Array()

    var idx = s
    for var i=0;i<count;i++  {
        ret.append(self[idx])
        idx += inc
    }
    return ret
  }
}

func kombinaatiot<T>(setti: Array<T>, k: Int) -> Array<Array<T>> {

var i: Int, j: Int

if (k > setti.count || k <= 0) {
    return []
}

if (k == setti.count) {
    return [setti]
}

if (k == 1) {
    var combs: Array<T> = []

    for var i = 0; i < setti.count; i++ {
        combs += [setti[i]]
    }
    return [combs]
}

var combs: Array<Array<T>> = [[]]

for var i = 0; i < setti.count - k + 1; i++ {
    var head = setti.slice(i,i + 1)
var tailcombs = kombinaatiot(setti.slice(i + 1), k - 1)
    for var j = 0; j < tailcombs.count; j++ {
combs += ([head + tailcombs[j]])

    }
}
    println(combs)
   return combs
}

但问题是我的功能打印

[[], [1, 2, 2, 3, 4], [2, 3, 3, 4], [3, 4, 4]]

当它应该打印的时候

[[1,2], [1,3], [2, 3]

我做错了什么？我不擅长编码，我的javascript技能也不是很好，但javascript对我来说很有用，但在swift中我无法做到这一点。

Answer 1

Swift翻译中的主要错误是对JavaScriptslice（start，end）方法的误解：该方法返回具有从给定开始索引到但不包括给定结束索引的索引的元素。您的Swift方法包括结束索引，这是错误的。

但Swift已经内置了带有订阅和范围语法的切片。例子：

let a = [0, 1, 2, 3]
let b = Array(a[1 ..< 3]) // from index 1 up to (but not including) 3
println(b) // [1, 2]

另一个错误是（可能已经存在于JavaScript代码中），对于k==0，您必须返回[[]]，即包含空选择的数组，而不是[]。事实上，这是唯一需要特别处理的案件。递归自动正确处理所有其他情况。

最后，在一般情况下，您必须从一个空数组开始：

var combs: Array<Array<T>> = [] // not [[]]

这给出了以下方法：

func kombinaatiot<T>(setti: [T], k: UInt) -> [[T]] {

    if k == 0 {
        return [[]]
    }

    var combs: [[T]] = []
    for (i, head) in enumerate(setti) {
        let tailcombs = kombinaatiot(Array(setti[i+1 ..< setti.count]), k - 1)
        for tc in tailcombs {
            combs += [[head] + tc]
        }
    }
    return combs
}

一些评论：

• [T]是数组的简写符号