如何获取（了:)指数返回多个指标？

Question

下面是一组阵列。

var group = ["H","H","E","D",
             "G","D","G","E",
             "D","B","A","B",
             "A","A","G","C",
             "C","H","D","G",
             "H","B","E","F",
             "F","C","E","A",
             "B","C","F","F"]

我想要做这样的事情找到“A”的指数。

group.index(of: "A"!)

但是，这将只返回第一个索引，而不是其他指数接下来的三个“A”秒。

print(group.index(of: "A")!) //10

我该怎么做才能让程序返回“A”的所有四个指标？

Answer 1

您可以使用enumerated和compactMap的组合：

let indexArray = group.enumerated().compactMap {
   $0.element == "A" ? $0.offset : nil
}    
print(indexArray) // [10, 12, 13, 27]

Answer 2

或者只是列举/过滤/图：

 group.enumerated().filter{$1=="A"}.map{$0.offset}

[编辑]更改$ 0.0至$ 0.offset按照亚历山大的建议（使代码更易读/显性）

Answer 3

您可以使用一个简单的循环

使用此代码

var group = ["H","H","E","D",
             "G","D","G","E",
             "D","B","A","B",
             "A","A","G","C",
             "C","H","D","G",
             "H","B","E","F",
             "F","C","E","A",
             "B","C","F","F"]
var indexes : [Int] = []
for (index,string) in group.enumerated() {
    if(string == "A") {
        indexes.append(index)
    }
}

debugPrint(indexes)

Answer 4

为了完整起见，这是另一种不同的做法，filters的indices

let group = ["H","H","E","D",
             "G","D","G","E",
             "D","B","A","B",
             "A","A","G","C",
             "C","H","D","G",
             "H","B","E","F",
             "F","C","E","A",
             "B","C","F","F"]

let indices = group.indices.filter{ group[$0] == "A"}

Answer 5

Vadian的回答above已经是最简洁的呢。

答案其余恰恰舞约链HUFs因为它很酷，但只是真实完整性，作为最基本的实现一个显然做到以下几点：

let group = ["H","H","E","D",
             "G","D","G","E",
             "D","B","A","B",
             "A","A","G","C",
             "C","H","D","G",
             "H","B","E","F",
             "F","C","E","A",
             "B","C","F","F"]

var array = [Int]()
for index in 0..<group.count {
    if group[index] == "A" {
        array.append(index)
    }
}

Answer 6

一个reduce，一般的，基础的解决方案：

let group = ["H","H","E","D",
             "G","D","G","E",
             "D","B","A","B",
             "A","A","G","C",
             "C","H","D","G",
             "H","B","E","F",
             "F","C","E","A",
             "B","C","F","F"]

extension Array where Element: Equatable {
    func indexes(of element: Element) -> [Index] {
        return enumerated().reduce([]) { $1.element == element ? $0 + [$1.offset] : $0 }
    }
}

group.indexes(of: "A") // 10, 12, 13, 27]

另一种方法是将建成一个字母到指数字典和查询的是：

let indices = Dictionary(group.enumerated().map { ($1, [$0]) }, uniquingKeysWith: +)
indices["A"] ?? [] // [10, 12, 13, 27]

虽然这个解决方案你需要解开的结果作为字典标返回一个可选值。

顺便说一句，你的阵列可以一直一个let而不是var，常量带来可预测性在你的代码，我推荐使用它们尽可能。

Answer 7

阅读Extensions和函数式编程过去几天后，我想尝试写Array类的扩展功能。这里是：

var group = ["H","H","E","D",
             "G","D","G","E",
             "D","B","A","B",
             "A","A","G","C",
             "C","H","D","G",
             "H","B","E","F",
             "F","C","E","A",
             "B","C","F","F"]

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

// Create a nice Array extension method that will return indices of wanted group.

extension Array where Element: Equatable {

func showIndices(indexOf groupName: Element) -> [Int] {
    return self.enumerated().compactMap {
        $0.element == groupName ? $0.offset : nil
    }
}
}

group.showIndices(indexOf: "A")
group2.showIndices(indexOf: 1)

// [10, 12, 13, 27]
// [0]