Arrays 在Swift中将数组拆分为子数组 问题

给定一个值数组如何将其拆分为由相等元素组成的

子数组

例子 给定这个数组

let numbers = [1, 1, 1, 3, 3, 4]

我想要这个输出

[[1,1,1], [3, 3], [4]]

我不是在找什么 解决这一问题的一种可能方法是创建某种索引，以指示每个元素的出现情况

let indexes = [1:3, 3:2, 4:1]

最后使用索引重建输出数组

let subsequences = indexes.sort { $0.0.0 < $0.1.0 }.reduce([Int]()) { (res, elm) -> [Int] in
    return res + [Int](count: elm.1, repeatedValue: elm.0)
}

最后考虑 实际上，我正在寻找的函数是与

flatte（）

相反的函数

let subsequences: [[Int]] = [[1,1,1], [3, 3], [4]]
print(Array(subsequences.flatten())) // [1, 1, 1, 3, 3, 4]

---

我希望我说得很清楚，如果您需要更多详细信息，请告诉我。

假设您有一个未排序的项目数组。您需要对初始数组进行排序，然后您将得到如下内容：

[1,1,1,3,3,4]

之后，您将初始化两个数组：一个用于存储数组，另一个用于将其用作当前数组

循环遍历初始数组并执行以下操作：

• 如果当前值与上一个值相同，则将其推送到当前数组
• 否则，将当前数组推送到第一个数组，然后清空当前数组

---

希望有帮助

如果您可以使用CocoaPods/Carthage/Swift Package Manager等。您可以使用提供

group（）方法的软件包：

numbers.lazy.group()
// should return a sequence that generates [1, 1, 1], [3, 3], [4].

或提供
groupBy
：

groupBy(SequenceOf(numbers), ==)


如果不想添加外部依赖项，可以编写如下算法：

func group<S: SequenceType where S.Generator.Element: Equatable>(seq: S) -> [[S.Generator.Element]] {
    var result: [[S.Generator.Element]] = []
    var current: [S.Generator.Element] = []
    for element in seq {
        if current.isEmpty || element == current[0] {
            current.append(element)
        } else {
            result.append(current)
            current = [element]
        }
    }
    result.append(current)
    return result
}

group(numbers)
// returns [[1, 1, 1], [3, 3], [4]].

func组（seq:S）->[[S.Generator.Element]]{
变量结果：[[S.Generator.Element]=[]
无功电流：[S.Generator.Element]=[]
对于seq中的元素{
如果current.isEmpty | |元素==当前[0]{
当前.append（元素）
}否则{
结果追加（当前）
当前=[元素]
}
}
结果追加（当前）
返回结果
}
组（数字）
//返回[[1,1,1]，[3,3]，[4]]。

[编辑]更改为使用Hamish建议的设置初始值设定项

[EDIT2]Swift 4在字典中添加了一个初始值设定项，可以更有效地执行此操作：

 let numberGroups = Array(Dictionary(grouping:numbers){$0}.values)

对于要按其属性之一分组的对象列表：

 let objectGroups = Array(Dictionary(grouping:objects){$0.property}.values)

以下是Swift 5的序列扩展：

extension Sequence where Iterator.Element: Equatable {

    func groupedElements() -> [[Iterator.Element]] {
        var result: [[Iterator.Element]] = []
        var current: [Iterator.Element] = []
        for element in self {
            if current.isEmpty || element == current[0] {
                current.append(element)
            } else {
                result.append(current)
                current = [element]
            }
        }
        result.append(current)
        return result
    }

}

值得一提的是，现在使用的是一行程序：

import Algorithms
let numbers = [1, 1, 1, 3, 3, 4]
let chunks: [[Int]] = numbers.chunked(by: ==).map { .init($0) }
print(chunks) // [[1, 1, 1], [3, 3], [4]]

为什么要使用
reduce
来创建
集合
？你可以直接使用
集合
初始化器：
集合（数字）。映射…
你是对的，哈米什，我不确定集合初始化器是否允许重复，但它确实有效，而且更清晰。但是，由于OP打算使用结构的内部属性，因此最终需要一个.map（）或原始的reduce。@AlainT。我有一个自定义对象数组，需要根据一个属性将其拆分为子数组。我试图稍微修改你的代码来实现这一点，但我得到了重复。我的更改如下所示：let itemsGrouped=Set（items！）.map{return items中的值！.filter{$0.custProp==value.custProp}}如果custProp在Swift 4:Array（Dictionary）（分组：items）中是hashtable，则需要如何更改？Set（items！.map{$0.custProp==value}）。map{return items中的值！.filter{$0.custProp==value}{$0.custProp}.values）我认为仅仅为了使用一个简单的分组函数而添加一个完整的依赖项有点太多了。+1对于算法解决方案，我使用的方法是将它实现到
扩展中
extension Sequence where Iterator.Element: Equatable {

    func groupedElements() -> [[Iterator.Element]] {
        var result: [[Iterator.Element]] = []
        var current: [Iterator.Element] = []
        for element in self {
            if current.isEmpty || element == current[0] {
                current.append(element)
            } else {
                result.append(current)
                current = [element]
            }
        }
        result.append(current)
        return result
    }

}

import Algorithms
let numbers = [1, 1, 1, 3, 3, 4]
let chunks: [[Int]] = numbers.chunked(by: ==).map { .init($0) }
print(chunks) // [[1, 1, 1], [3, 3], [4]]