將陣列溢位成對

我正在嘗試將陣列拆分成對。我可以分成連續的對，但我想分成包括結果中提到的先前值的對

邏輯分裂成連續對，我試過了。

extension Array {
func chunks(_ chunkSize: Int) -> [[Element]] {
    return stride(from: 0, to: self.count, by: chunkSize).map {
        Array(self[$0..<Swift.min($0   chunkSize, self.count)])
    }
}

大批：

["1", "2", "3", "4", "5", "6", "7", "8", "9"]

結果：

[["1", "2"], ["2", "3"], ["3", "4"], ["4", "5"], ["6", "7"], ["7", "8"], ["8", "9"]]

uj5u.com熱心網友回復：

這個怎么樣：

let a = [ 1, 2, 3, 4, 5, 6, 7, 8, 9]

let pairs = Array(zip(a, a.dropFirst())).map {[$0.0, $0.1] }

print(pairs)

那輸出

[[1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9]]

編輯：

如果你想要任意塊大小，你可以這樣寫擴展：

extension Array {
    func chunks(_ chunkSize: Int, includePartialChunk: Bool = true) -> [[Element]] {
        var indexes = Array<Int>(stride(from: 0, to: count, by: chunkSize - 1))
        if includePartialChunk,
           let last = indexes.last,
           last < count - 1 {
            indexes.append(count-1)
        }
        return zip(indexes, indexes.dropFirst()).map {Array(self[$0.0...$0.1])}
    }
}

includePartialChunk當陣列大小不是塊大小的偶數倍時，使用引數告訴函式是否要在末尾包含“部分塊”。如果為 true（默認值），則回傳小于 chunkSize 但到達陣列末尾的最后一個塊。如果為 false，它只回傳完整大小的塊，但會在末尾跳過不適合完整大小的塊的陣列元素。

（我將不得不研究 Leo 的UnfoldSequence版本，看看我是否可以調整我的代碼。）

uj5u.com熱心網友回復：

不是對這個問題的直接回答，但應該懶惰地計算序列的元素。您應該使用 SwiftUnfoldSequence型別，如下所示：

extension Collection {
    var unfoldedNeighbors: UnfoldSequence<SubSequence,Index> {
        sequence(state: startIndex) { start in
            guard start < self.endIndex else { return nil }
            guard let end = self.index(start, offsetBy: 2, limitedBy: self.endIndex) else {
                return nil
            }
            defer { start = self.index(start, offsetBy: 1, limitedBy: self.endIndex) ?? self.endIndex }
            return self[start..<end]
        }
    }
    var neighborsSubsequences: [SubSequence] {
        .init(unfoldedNeighbors)
    }
    var neighborsArrays: [[Element]] {
        unfoldedNeighbors.map([Element].init)
    }
}

用法：

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
for neighbors in numbers.unfoldedNeighbors {
    print(neighbors)
}

如果您需要控制每個子序列的元素數量以及它是否包含尾部：

extension Collection {
    func unfoldedNeighbors(limitedTo length: Int, includesTail: Bool = false) -> UnfoldSequence<SubSequence,Index> {
        sequence(state: startIndex) { start in
            guard start < self.endIndex else { return nil }
            guard let end = self.index(start, offsetBy: length, limitedBy: self.endIndex) else {
                if includesTail {
                    defer { start = self.index(start, offsetBy: length-1, limitedBy: self.endIndex) ?? self.endIndex }
                    return self[start...]
                }
                return nil
            }
            defer { start = self.index(start, offsetBy: length-1, limitedBy: self.endIndex) ?? self.endIndex }
            return self[start..<end]
        }
    }
    func neighborsSequences(limitedTo length: Int, includesTail: Bool = false) -> [SubSequence] {
        .init(unfoldedNeighbors(limitedTo: length, includesTail: includesTail))
    }
    func neighborsArrays(limitedTo length: Int, includesTail: Bool = false) -> [[Element]] {
        unfoldedNeighbors(limitedTo: length, includesTail: includesTail).map([Element].init)
    }
}

用法：

let numbers = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for neighbors in numbers.unfoldedNeighbors(limitedTo: 3, includesTail: true) {
    print(neighbors)
}

這將列印：

[1, 2, 3]
[3, 4, 5]
[5, 6, 7]
[7, 8, 9]
[9, 10]

let neighborsSequences = a.neighborsSequences(limitedTo: 3, includesTail: true)  // [[1, 2, 3], [3, 4, 5], [5, 6, 7], [7, 8, 9], [9, 10]] of type [Array<Int>.SubSequence]
let neighborsArrays = a.neighborsArrays(limitedTo: 3, includesTail: true)        // [[1, 2, 3], [3, 4, 5], [5, 6, 7], [7, 8, 9], [9, 10]] of type [[Int]]

標籤：

上一篇：Typescript-使用陣列引數中的元素作為回傳型別

下一篇：有沒有一種簡單的方法來展平一組物件，同時制作一個不同的列的陣列？