从数组中提取元素并将它们放回另一个数组。

Question

假设我有一个包含10个元素的数组。比方说，

var ArrayElemts : ["1","2","3","4","5","6","7","8","9","10","11"]

现在我如何将元素从0 t0 5保存在一个数组中，将6到10保存到另一个数组中？

Answer 1

最简单的选项如下：

let partition1 = array.filter { Int($0) ?? 0 <= 5 }
let partition2 = array.filter { Int($0) ?? 0 > 5 }

转换为数字应该是第一步。你永远不应该使用字符串，就好像它们是数字一样。

let numbers = array.flatMap { Int($0) }

let partition1 = numbers.filter { $0 <= 5 }
let partition2 = numbers.filter { $0 > 5 }

如果我们假设数组已排序，则有更简单的选项：

let sorted = numbers.sorted()
let partition1: [Int]
let partition2: [Int]

if let partition2start = sorted.index(where: { $0 > 5 }) {
    partition1 = Array(sorted.prefix(upTo: partition2start))
    partition2 = Array(sorted.suffix(from: partition2start))
} else {
    partition1 = sorted
    partition2 = []
}

这是本机partition方法可以执行的操作：

var numbers = array.flatMap { Int($0) }
let index = numbers.partition { $0 > 5 }
let partition1 = Array(numbers.prefix(upTo: index))
let partition2 = Array(numbers.suffix(from: index))

注意该方法会更改原始数组。

Answer 2

使用[0...5]创建ArraySlice，然后Array将其转换回数组：

var arrayElemts = ["1","2","3","4","5","6","7","8","9","10","11"]

let first = Array(arrayElemts[0...5])
let second = Array(arrayElemts[6...10])

print(first)   // ["1", "2", "3", "4", "5", "6"]
print(second)  // ["7", "8", "9", "10", "11"]

Answer 3

将阵列分解为N大小的块

其他答案向您展示如何静态地＃34;使用ArraySlice：s将原始数组分区到不同的数组中。根据您的描述，您可能希望通常将原始数组拆分为N大小的块（此处为：n = 5）。

我们可以使用sequence(state:next)来实现这样的chunk(bySize:)方法作为Collection的扩展：

extension Collection {
    func chunk(bySize size: IndexDistance) -> [SubSequence] {
        precondition(size > 0, "Chunk size must be a positive integer.")
        return sequence(
            state: (startIndex, index(startIndex, offsetBy: size, limitedBy: endIndex) ?? endIndex),
            next: { indices in
            guard indices.0 != self.endIndex else { return nil }
            indices.1 = self.index(indices.0, offsetBy: size, limitedBy: self.endIndex) ?? self.endIndex
            return (self[indices.0..<indices.1], indices.0 = indices.1).0
        }).map { $0 }
    }
}

应用于您的示例：

var arrayElements = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11"]
let partitions = arrayElements.chunk(bySize: 5)
/* [["1", "2", "3", "4", "5"],
    ["6", "7", "8", "9", "10"],
    ["11"]] */

chunk(bySize:)方法会将数组拆分为bySize大小的块，以及（可能）最终分区的较小块。

然而，尽管我想尝试使用sequence(state:next)函数（不需要使用state以外的任何可变中间变量），但上面的实现非常臃肿难以阅读，所以（对于许多其他情况......）我们最好只使用while循环：

extension Collection {
    func chunk(bySize size: IndexDistance) -> [SubSequence] {
        precondition(size > 0, "Chunk size must be a positive integer.")
        var chunks: [SubSequence] = []
        var from = startIndex
        while let to = index(from, offsetBy: size, limitedBy: endIndex) {
            chunks.append(self[from..<to])
            from = to
        }
        if from != endIndex { chunks.append(self[from..<endIndex]) }
        return chunks
    }
}

Answer 4

大声笑，我不明白为什么这里有如此复杂的答案 （考虑＆＃34;数组＆＃34;变量原样 - ＆gt; [Int]，而不是[Any]） 所以第一种方法只适用于Number类型。 第二个应该这样做

简单地：

let array = [0,1,2,3,4,5,6,7,8,9,10]
//For instance..
var arrayA = ["A","B","C","D","E","F","G"]

//First 6 elements
let arrayOfFirstFour = array.filter({
    return $0 <= 5 ? true : false
})

//Remaining  elements:
let restOfArray = array.filter({
    return $0 > 5 ? true : false
})

let elementsToFourth = arrayA.prefix(upTo: 4)
let elementsAfterFourth = arrayA.suffix(from: 4)
print(arrayOfFirstFour)
print(restOfArray)
print(elementsToFourth)
print(elementsAfterFourth)

//[0, 1, 2, 3, 4, 5]
//[6, 7, 8, 9, 10]
//["A", "B", "C", "D"]
//["E", "F", "G"]