你所描述的就是所谓的“窗口”。“它在数字信号处理中非常常见，并且在swift-algorithms中开箱即用。有关swift-algorithms包及其在Swift生态系统中的作用的更多信息，请参阅Announcing Swift Algorithms。
如果你想看一个算法如何工作的例子，请查看the source。他们使用数据结构WindowsOfCountCollection来实现它，而不是创建一堆zip等。这通常更有效，因为窗口是按需生成的，并且不必预先分配大量内存。

我想知道我是否可以用一种更“迅捷”的方式重写它，使用像stride，map，reduce或其他我缺少的功能？“**.
是的，您可以使用集合func sequence<T, State>(state: State, next: @escaping (inout State) -> T?) -> UnfoldSequence<T, State>方法创建自己的方法，如下所示：

extension Collection {
    func windows(of count: Int) -> UnfoldSequence<SubSequence,Index> {
        sequence(state: startIndex) { start in
            guard start < endIndex,
                let end = index(
                    start,
                    offsetBy: count,
                    limitedBy: endIndex
                )
            else { return nil }
            defer { formIndex(after: &start) }
            return self[start..<end]
        }
    }
}

使用方法：

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
let windows = numbers.windows(of: 3)
for window in windows {
    print(window)
}

这将打印：
[一、二、三]
[二、三、四]
[3、4、5]
[4、5、6]
[5、6、7]
[6、7、8]
[7、8、9]
[8、9、10]
请注意，结果序列的元素是惰性计算的。它将返回一个UnfoldSequence，而不复制原始元素。
如果你需要输出一个子序列数组，你可以这样做：

extension Collection {
    func windows(of count: Int) -> [SubSequence] {
        .init(sequence(state: startIndex) { start in
            guard start < endIndex,
                let end = index(
                    start,
                    offsetBy: count,
                    limitedBy: endIndex
                )
            else { return nil }
            defer { formIndex(after: &start) }
            return self[start..<end]
        })
    }
}

如果你真的需要复制结果元素并输出数组的数组：

extension Collection  {
    func windows(of count: Int) -> [[Element]] {
        .init(sequence(state: startIndex) { start in
            guard start < endIndex,
                let end = index(
                    start,
                    offsetBy: count,
                    limitedBy: endIndex
                )
            else { return nil }
            defer { formIndex(after: &start) }
            return .init(self[start..<end])
        })
    }
}

stride()或多或少是一个具有不同于1的增量的for循环。但是在这里，你想迭代每个元素（即，递增1），并将接下来的n个元素与之一起使用。
我发现这个问题很有趣，所以这里有“两个”其他方法。
数组有索引，所以你可以使用它们，有时，我们倾向于忘记它们（关于indices值，每次都使用someArray[index]）。
我在第一个解决方案中使用compactMap()。这或多或少是一个简单的循环。它的一个小缺点是，如果你的数组有n个元素，它将迭代n次，而不是“n - size”。
我在第二个解决方案中使用map。它或多或少是一个简单的循环。我计算了before和end，避免了前面的解决方案中不必要的迭代。
如果需要的话，你可以把这两种想法结合起来。不清楚如何处理大小限制，如0、size〉count等，所以我保留了日志。

extension Array {
    func windows(size: Int) -> [[Element]] {
        indices.compactMap { anElement in
            let end = anElement.advanced(by: size)
            guard end <= count else { return nil }
            return Array(self[anElement ..< end])
        }
    }

    func windows2(size: Int) -> [[Element]] {
        guard size <= count else { return [] } //We check before, else, the next line will crash
        let end = indices.upperBound.advanced(by: -size)
        return (indices.lowerBound...end).map {
            Array(self[$0..<$0.advanced(by: size)])
        }
    }
}

游戏测试：

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

print("Window: 3") //"Normal" behavior
print(initialArray.windows(size: 3))
print(initialArray.windows2(size: 3))
print("Window: 10") //Size = count
print(initialArray.windows(size: 10))
print(initialArray.windows2(size: 10))
print("Window: 0") //No size
print(initialArray.windows(size: 0))
print(initialArray.windows2(size: 0))
print("Window: 1") //Size of 1
print(initialArray.windows(size: 1))
print(initialArray.windows2(size: 1))
print("Window: 11") //Window greater than the count
print(initialArray.windows(size: 11))
print(initialArray.windows2(size: 11))

输出：

Window: 3
[[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7], [6, 7, 8], [7, 8, 9], [8, 9, 10]]
[[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7], [6, 7, 8], [7, 8, 9], [8, 9, 10]]
Window: 10
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]
Window: 0
[[], [], [], [], [], [], [], [], [], []]
[[], [], [], [], [], [], [], [], [], [], []] //Here there is a differenccec
Window: 1
[[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]]
[[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]]
Window: 11
[]
[]