Swift: каков правильный способ разделить [String], что приводит к [[String]] с заданным размером подмассива?

Ответ 1

Я бы не назвал это красивым, но здесь метод с использованием map:

let numbers = ["1","2","3","4","5","6","7"]
let splitSize = 2
let chunks = numbers.startIndex.stride(to: numbers.count, by: splitSize).map {
  numbers[$0 ..< $0.advancedBy(splitSize, limit: numbers.endIndex)]
}

Метод stride(to:by:) дает вам индексы для первого элемента каждого фрагмента, поэтому вы можете сопоставить эти индексы с срезом исходного массива с помощью advancedBy(distance:limit:).

Более "функциональный" подход просто состоял бы в том, чтобы перезаписать массив, например:

func chunkArray<T>(s: [T], splitSize: Int) -> [[T]] {
    if countElements(s) <= splitSize {
        return [s]
    } else {
        return [Array<T>(s[0..<splitSize])] + chunkArray(Array<T>(s[splitSize..<s.count]), splitSize)
    }
}

Ответ 2

В Swift 3/4 это будет выглядеть следующим образом:

let numbers = ["1","2","3","4","5","6","7"]
let chunkSize = 2
let chunks = stride(from: 0, to: numbers.count, by: chunkSize).map {
    Array(numbers[$0..<min($0 + chunkSize, numbers.count)])
}
// prints as [["1", "2"], ["3", "4"], ["5", "6"], ["7"]]

В качестве расширения для массива:

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

Или немного более подробный, но более общий:

let numbers = ["1","2","3","4","5","6","7"]
let chunkSize = 2
let chunks: [[String]] = stride(from: 0, to: numbers.count, by: chunkSize).map {
    let end = numbers.endIndex
    let chunkEnd = numbers.index($0, offsetBy: chunkSize, limitedBy: end) ?? end
    return Array(numbers[$0..<chunkEnd])
}

Это более общее, потому что я делаю меньше предположений о типе индекса в коллекции. В предыдущей реализации я предположил, что их можно было бы сравнить и добавить.

Обратите внимание, что в Swift 3 функциональность продвигающихся индексов была перенесена из самих индексов в коллекцию.

Ответ 3

С Swift 5, в соответствии с вашими потребностями, вы можете выбрать один из пяти следующих способов, чтобы решить вашу проблему.

1. Использование AnyIterator в методе расширения Collection

AnyIterator является хорошим кандидатом для перебора индексов объекта, соответствующего протоколу Collection, для возврата подпоследовательностей этого объекта. В расширении протокола Collection вы можете объявить метод chunked(by:) со следующей реализацией:

extension Collection {

    func chunked(by distance: Int) -> [[Element]] {
        precondition(distance > 0, "distance must be greater than 0") // prevents infinite loop

        var index = startIndex
        let iterator: AnyIterator<Array<Element>> = AnyIterator({
            let newIndex = self.index(index, offsetBy: distance, limitedBy: self.endIndex) ?? self.endIndex
            defer { index = newIndex }
            let range = index ..< newIndex
            return index != self.endIndex ? Array(self[range]) : nil
        })

        return Array(iterator)
    }

}

Использование:

let array = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
let newArray = array.chunked(by: 2)
print(newArray) // prints: [["1", "2"], ["3", "4"], ["5", "6"], ["7", "8"], ["9"]]

2. Использование функции stride(from:to:by:) в методе расширения Array

Индексы Array имеют тип Int и соответствуют протоколу Strideable. Следовательно, вы можете использовать их с stride(from:to:by:) и advanced(by:). В расширении Array вы можете объявить метод chunked(by:) со следующей реализацией:

extension Array {

    func chunked(by distance: Int) -> [[Element]] {
        let indicesSequence = stride(from: startIndex, to: endIndex, by: distance)
        let array: [[Element]] = indicesSequence.map {
            let newIndex = $0.advanced(by: distance) > endIndex ? endIndex : $0.advanced(by: distance)
            //let newIndex = self.index($0, offsetBy: distance, limitedBy: self.endIndex) ?? self.endIndex // also works
            return Array(self[$0 ..< newIndex])
        }
        return array
    }

}

Использование:

let array = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
let newArray = array.chunked(by: 2)
print(newArray) // prints: [["1", "2"], ["3", "4"], ["5", "6"], ["7", "8"], ["9"]]

3. Использование рекурсивного подхода в методе расширения Array

На основе рекурсивного кода Nate Cook вы можете объявить метод chunked(by:) в расширении Array со следующей реализацией:

extension Array {

    func chunked(by distance: Int) -> [[Element]] {
        precondition(distance > 0, "distance must be greater than 0") // prevents infinite loop

        if self.count <= distance {
            return [self]
        } else {
            let head = [Array(self[0 ..< distance])]
            let tail = Array(self[distance ..< self.count])
            return head + tail.chunked(by: distance)
        }
    }

}

Использование:

let array = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
let newArray = array.chunked(by: 2)
print(newArray) // prints: [["1", "2"], ["3", "4"], ["5", "6"], ["7", "8"], ["9"]]

4. Использование цикла for и пакетов в методе расширения Collection

Крис Эйдхоф и Флориан Куглер показывают в видеоролике Swift Talk # 33 - Sequence & Iterator (Collections # 2) видео, как использовать простой цикл for для заполнения пакетов элементов последовательности и добавления их по завершении в массив. В расширении Sequence вы можете объявить метод chunked(by:) со следующей реализацией:

extension Collection {

    func chunked(by distance: Int) -> [[Element]] {
        var result: [[Element]] = []
        var batch: [Element] = []

        for element in self {
            batch.append(element)

            if batch.count == distance {
                result.append(batch)
                batch = []
            }
        }

        if !batch.isEmpty {
            result.append(batch)
        }

        return result
    }

}

Использование:

let array = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
let newArray = array.chunked(by: 2)
print(newArray) // prints: [["1", "2"], ["3", "4"], ["5", "6"], ["7", "8"], ["9"]]

5. Использование пользовательской struct, соответствующей протоколам Sequence и IteratorProtocol

Если вы не хотите создавать расширения Sequence, Collection или Array, вы можете создать собственную struct, соответствующую протоколам Sequence и IteratorProtocol. Эта struct должна иметь следующую реализацию:

struct BatchSequence<T>: Sequence, IteratorProtocol {

    private let array: [T]
    private let distance: Int
    private var index = 0

    init(array: [T], distance: Int) {
        precondition(distance > 0, "distance must be greater than 0") // prevents infinite loop
        self.array = array
        self.distance = distance
    }

    mutating func next() -> [T]? {
        guard index < array.endIndex else { return nil }
        let newIndex = index.advanced(by: distance) > array.endIndex ? array.endIndex : index.advanced(by: distance)
        defer { index = newIndex }
        return Array(array[index ..< newIndex])
    }

}

Использование:

let array = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
let batchSequence = BatchSequence(array: array, distance: 2)
let newArray = Array(batchSequence)
print(newArray) // prints: [["1", "2"], ["3", "4"], ["5", "6"], ["7", "8"], ["9"]]

Ответ 4

Мне нравится ответ Nate Cook, похоже, что Swift движется дальше, так как он был написан, здесь я рассматриваю это как расширение для массива:

extension Array {
    func chunk(chunkSize : Int) -> Array<Array<Element>> {
        return 0.stride(to: self.count, by: chunkSize)
            .map { Array(self[$0..<$0.advancedBy(chunkSize, limit: self.count)]) }
    }
}

Обратите внимание: он возвращает [] для отрицательных чисел и приводит к фатальной ошибке, как указано выше. Вам нужно будет включить охрану, если вы хотите это предотвратить.

func testChunkByTwo() {
    let input = [1,2,3,4,5,6,7]
    let output = input.chunk(2)
    let expectedOutput = [[1,2], [3,4], [5,6], [7]]
    XCTAssertEqual(expectedOutput, output)
}

func testByOne() {
    let input = [1,2,3,4,5,6,7]
    let output = input.chunk(1)
    let expectedOutput = [[1],[2],[3],[4],[5],[6],[7]]
    XCTAssertEqual(expectedOutput, output)
}

func testNegative() {
    let input = [1,2,3,4,5,6,7]
    let output = input.chunk(-2)
    let expectedOutput = []
    XCTAssertEqual(expectedOutput, output)
}

Ответ 5

Я не думаю, что вы захотите использовать карту или уменьшить ее. Карта предназначена для применения функции к каждому отдельному элементу в массиве, а сокращение - для выравнивания массива. То, что вы хотите сделать, - это разрезать массив на подмассивы определенного размера. Этот фрагмент использует срезы.

var arr = ["1","2","3","4","5","6","7"]
var splitSize = 2

var newArr = [[String]]()
var i = 0
while i < arr.count {
    var slice: Slice<String>!
    if i + splitSize >= arr.count {
        slice = arr[i..<arr.count]
    }
    else {
        slice = arr[i..<i+splitSize]
    }
    newArr.append(Array(slice))
    i += slice.count
}
println(newArr)

Ответ 6

Вышеизложенное очень клеверное, но у меня болит голова. Я должен был вернуться к менее осторожному подходу.

Для Swift 2.0

var chunks = [[Int]]()
var temp = [Int]()
var splitSize = 3

var x = [1,2,3,4,5,6,7]

for (i, element) in x.enumerate() {

    if temp.count < splitSize {
        temp.append(element)
    }
    if temp.count == splitSize {
        chunks.append(temp)
        temp.removeAll()
    }
}

if !temp.isEmpty {
    chunks.append(temp)
}

Playground Result [[1, 2, 3], [4, 5, 6], [7]]

Ответ 7

Было бы приятно выразить формулировку Тайлера Клутиера в качестве расширения на Array:

extension Array {
    func chunked(by chunkSize:Int) -> [[Element]] {
        let groups = stride(from: 0, to: self.count, by: chunkSize).map {
            Array(self[$0..<[$0 + chunkSize, self.count].min()!])
        }
        return groups
    }
}

Это дает нам общий способ разбиения массива на куски.

Ответ 8

Новое в Swift 4, вы можете сделать это эффективно с помощью reduce(into:). Здесь расширение по последовательности:

extension Sequence {
    func eachSlice(_ clump:Int) -> [[Self.Element]] {
        return self.reduce(into:[]) { memo, cur in
            if memo.count == 0 {
                return memo.append([cur])
            }
            if memo.last!.count < clump {
                memo.append(memo.removeLast() + [cur])
            } else {
                memo.append([cur])
            }
        }
    }
}

Использование:

let result = [1,2,3,4,5,6,7,8,9].eachSlice(2)
// [[1, 2], [3, 4], [5, 6], [7, 8], [9]]

Ответ 9

Я просто брошу свою шляпу в кольцо здесь с другой реализацией на основе AnyGenerator.

extension Array {
    func chunks(_ size: Int) -> AnyIterator<[Element]> {
        if size == 0 {
            return AnyIterator {
                return nil
            }
        }

        let indices = stride(from: startIndex, to: count, by: size)
        var generator = indices.makeIterator()

        return AnyIterator {
            guard let i = generator.next() else {
                return nil
            }

            var j = self.index(i, offsetBy: size)
            repeat {
                j = self.index(before: j)
            } while j >= self.endIndex

            return self[i...j].lazy.map { $0 }
        }
    }
}

Я предпочитаю этот метод, поскольку он полагается исключительно на генераторы, которые могут иметь негативное влияние положительной памяти при работе с большими массивами.

Для вашего конкретного примера, как это работает:

let chunks = Array(["1","2","3","4","5","6","7"].chunks(2))

Результат:

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

Ответ 10

В Swift 4 или более поздней SubSequence вы также можете расширить Collection и вернуть ее коллекцию SubSequence чтобы иметь возможность использовать ее также с типами StringProtocol (String или Substring). Таким образом, он вернет коллекцию подстрок, а не коллекцию символов:

Xcode 10.1 • Swift 4.2.1 или новее

extension Collection {
    func subSequences(limitedTo maxLength: Int) -> [SubSequence] {
        precondition(maxLength > 0, "groups must be greater than zero")
        var start = startIndex
        return stride(from: 0, to: count, by: maxLength).map { _ in
            let end = index(start, offsetBy: maxLength, limitedBy: endIndex) ?? endIndex
            defer { start = end }
            return self[start..<end]
        }
    }
}

использование

let array = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
let slices = array.subSequences(limitedTo: 2)  // [ArraySlice(["1", "2"]), ArraySlice(["3", "4"]), ArraySlice(["5", "6"]), ArraySlice(["7", "8"]), ArraySlice(["9"])]
for slice in slices {
    print(slice) // prints: [["1", "2"], ["3", "4"], ["5", "6"], ["7", "8"], ["9"]]
}
// To convert from ArraySlice<Element> to Array<element>
let arrays = slices.map(Array.init)  // [["1", "2"], ["3", "4"], ["5", "6"], ["7", "8"], ["9"]]

extension Collection {
    var singles: [SubSequence] { return subSequences(limitedTo: 1) }
    var pairs:   [SubSequence] { return subSequences(limitedTo: 2) }
    var triples: [SubSequence] { return subSequences(limitedTo: 3) }
    var quads:   [SubSequence] { return subSequences(limitedTo: 4) }
}

Array или ArraySlice символов

let chars = ["a","b","c","d","e","f","g","h","i"]
chars.singles  // [["a"], ["b"], ["c"], ["d"], ["e"], ["f"], ["g"], ["h"], ["i"]]
chars.pairs    // [["a", "b"], ["c", "d"], ["e", "f"], ["g", "h"], ["i"]]
chars.triples  // [["a", "b", "c"], ["d", "e", "f"], ["g", "h", "i"]]
chars.quads    // [["a", "b", "c", "d"], ["e", "f", "g", "h"], ["i"]]
chars.dropFirst(2).quads  // [["c", "d", "e", "f"], ["g", "h", "i"]]

Элементы StringProtocol (String и SubString)

let str = "abcdefghi"
str.singles  // ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
str.pairs    // ["ab", "cd", "ef", "gh", "i"]
str.triples  // ["abc", "def", "ghi"]
str.quads    // ["abcd", "efgh", "i"]
str.dropFirst(2).quads    // ["cdef", "ghi"]

Ответ 11

Знаете ли вы, что любое решение с быстрым стилем [a... b] работает в 10 раз медленнее, чем обычно?

for y in 0..<rows {
    var row = [Double]()
    for x in 0..<cols {
        row.append(stream[y * cols + x])
    }
    mat.append(row)
}

Попробуй и посмотри, вот мой сырой код для теста:

let count = 1000000
let cols = 1000
let rows = count / cols
var stream = [Double].init(repeating: 0.5, count: count)

// Regular
var mat = [[Double]]()

let t1 = Date()

for y in 0..<rows {
    var row = [Double]()
    for x in 0..<cols {
        row.append(stream[y * cols + x])
    }
    mat.append(row)
}

print("regular: \(Date().timeIntervalSince(t1))")


//Swift
let t2 = Date()

var mat2: [[Double]] = stride(from: 0, to: stream.count, by: cols).map {
    let end = stream.endIndex
    let chunkEnd = stream.index($0, offsetBy: cols, limitedBy: end) ?? end
    return Array(stream[$0..<chunkEnd])
}

print("swift: \(Date().timeIntervalSince(t2))")

и out:

regular: 0.0449600219726562

swift: 0.49255496263504