Arrays 如何在Swift中将阵列拆分为两半？

我怎么分一副牌？我有一个阵列和一个随机的牌商，但不知道如何分割牌组

---

谢谢大家的帮助！我现在有一个工作卡应用程序，确实遇到了其他问题，但很快就解决了。

您可以使用下标范围

let deck: [String] = ["J", "Q", "K", "A"]

// use ArraySlice only for transient computation
let leftSplit: ArraySlice<String> = deck[0 ..< deck.count / 2] // "J", "Q"
let rightSplit: ArraySlice<String> = deck[deck.count / 2 ..< deck.count] // "K", "A"

// make arrays from ArraySlice
let leftDeck: [String] = Array(leftSplit) // "J", "Q"
let rightDeck: [String] = Array(rightSplit) // "K", "A"

let deck:[String]=[“J”、“Q”、“K”、“A”]
//仅将ArraySlice用于瞬态计算
让leftSplit:ArraySlice=deck[0..

---

编辑：以上代码适用于Swift 2，也许Swift 3更方便。

您可以进行扩展，以便它可以返回两个数组的数组，使用整数、字符串等：

extension Array {
    func split() -> [[Element]] {
        let ct = self.count
        let half = ct / 2
        let leftSplit = self[0 ..< half]
        let rightSplit = self[half ..< ct]
        return [Array(leftSplit), Array(rightSplit)]
    }
}

let deck = ["J", "Q", "K", "A"]
let nums = [0, 1, 2, 3, 4]

deck.split() // [["J", "Q"], ["K", "A"]]
nums.split() // [[0, 1], [2, 3, 4]]

扩展数组{
func split（）->[[Element]]{
让ct=self.count
设一半=ct/2
让leftSplit=self[0..

但返回一个命名元组更好，因为它强化了这样一个事实，即您希望结果正好是两个数组：

extension Array {
    func split() -> (left: [Element], right: [Element]) {
        let ct = self.count
        let half = ct / 2
        let leftSplit = self[0 ..< half]
        let rightSplit = self[half ..< ct]
        return (left: Array(leftSplit), right: Array(rightSplit))
    }
}

let deck = ["J", "Q", "K", "A"]

let splitDeck = deck.split()
print(splitDeck.left) // ["J", "Q"]
print(splitDeck.right) // ["K", "A"]

扩展数组{
func split（）->（左：[Element]，右：[Element]）{
让ct=self.count
设一半=ct/2
让leftSplit=self[0..

---

注意：Andrei和Qbyte给出了第一个正确答案，这要归功于他们，我只是在添加信息。

您可以在

SequenceType

上创建一个扩展，并创建一个名为

divide

的函数

此函数将遍历序列中的元素，同时将匹配谓词的元素放入一个数组（

切片

），将不匹配的元素放入另一个数组（

余数

）

函数返回一个元组，其中包含

切片

和

余数

extension SequenceType {

    /**
     Returns a tuple with 2 arrays.
     The first array (the slice) contains the elements of self that match the predicate.
     The second array (the remainder) contains the elements of self that do not match the predicate.
     */
    func divide(@noescape predicate: (Self.Generator.Element) -> Bool) -> (slice: [Self.Generator.Element], remainder: [Self.Generator.Element]) {
        var slice:     [Self.Generator.Element] = []
        var remainder: [Self.Generator.Element] = []
        forEach {
            switch predicate($0) {
            case true  : slice.append($0)
            case false : remainder.append($0)
            }
        }
        return (slice, remainder)
    }

}

这是一个例子

let tuple = [1, 2, 3, 4, 5].divide({ $0 >= 3 })
tuple.slice     // [3, 4, 5]
tuple.remainder // [1, 2]

---

Swift

将数组拆分为多个块的更通用的解决方案

扩展数组{
func分块（分为大小：Int）->[[Element]]{
返回步幅（从：0到：计数，按：大小）。映射{
数组（自身[$0..

以及之前提供的想法的另一个实现。首先，根据Swift当前文档，最好为产生某些结果的函数选择过去简单时态的名称，而为变异函数选择现在时态的名称。 其次，对于我来说，最好选择半加计数%2，以获得更统一的结果

这是：

extension Array {
    func devided() -> ([Element], [Element]) {
        let half = count / 2 + count % 2
        let head = self[0..<half]
        let tail = self[half..<count]

        return (Array(head), Array(tail))
    }
}

---

检查一下：您可能希望使用单独的数组，而不是

ArraySlice

。因此

Array（leftSplit）

将给出所需的结果。命名元组无疑是更好的方法。它让编译器强制要求您只需要两个arraysAgreed.：）根据你的评论，我已经稍微修改了我回答的措辞。“split”的过去式仍然是“split”。要遵循你所指的指导原则，可能最好找到一个split的同义词，它在过去时态中产生了不同的拼写。这与问题所问的有点误导。如果我指定2，那么我会得到几个数组，每个数组的大小为2。如果我指定了

计数的一半，那么当计数为奇数时，我将得到一个包含一个元素的额外数组。
extension Array {
    func devided() -> ([Element], [Element]) {
        let half = count / 2 + count % 2
        let head = self[0..<half]
        let tail = self[half..<count]

        return (Array(head), Array(tail))
    }
}

let set1 = [1, 2, 3, 4, 5, 6, 7,8]
let set2 = [1, 2, 3, 4, 5]
let set3 = [1]
let set4 = [Int]()

print(set1.devided())
print(set2.devided())
print(set3.devided())
print(set4.devided())

([1, 2, 3, 4], [5, 6, 7, 8])
([1, 2, 3], [4, 5])
([1], [])
([], [])