字典中的最高频率元素

Question

我正在尝试在给定中找到频率最高的元素，如下所示。

首先，我正在尝试构建一个字典并根据频率计算每个元素。

我不知道如何从构造的字典中提取最大值。

输入：[3,2,3]

输出：3

func majorityElement(_ nums1: [Int]) -> Int {

    var num1Dict = Dictionary(nums1.map{ ($0, 1) }, uniquingKeysWith : +)
    return num1Dict.values.max() // ????

}

Answer 1

您已经正确构造了num1Dict，对于输入[3,2,3]，它将是这样的：

[2:1, 3:2]

values.max() 将返回 2，因为在字典中的所有值（1 和 2）中，2 是最高的。

现在看到你的错误了吗？

您需要返回与最大值关联的键，而不是最大值。

一个非常简单的方法是这样做：

func majorityElement(_ nums1: [Int]) -> Int? { // you should probably return an optional here in case nums1 is empty

    let num1Dict = Dictionary(nums1.map{ ($0, 1) }, uniquingKeysWith : +)
    var currentHigh = Int.min
    var mostOccurence: Int?
    for kvp in num1Dict {
        if kvp.value > currentHigh {
            mostOccurence = kvp.key
            currentHigh = kvp.value
        }
    }
    return mostOccurence

}

Answer 2

您可以使用reduce(into:) 生成带有元素及其频率的Dictionary，然后使用这些频率对数组进行排序，然后简单地返回排序后数组的最后一个元素（基于升序）。

extension Array where Element: Comparable & Hashable {
    func sortByNumberOfOccurences() -> [Element] {
        let occurencesDict = self.reduce(into: [Element:Int](), { currentResult, element in
            currentResult[element, default: 0] += 1
        })
        return self.sorted(by: { current, next in occurencesDict[current]! < occurencesDict[next]!})
    }

    func elementWithHighestFrequency() -> Element? {
        return sortByNumberOfOccurences().last
    }
}

免责声明：sortByNumberOfOccurences 方法是从another answer of mine 复制而来的。

Answer 3

您要查找的内容（集合中最常见的元素）的数学名称称为模式。可能有联系（例如[1, 1, 2, 2, 3, 3] 有 3 种模式：[1, 2, 3]）

如果你想要任何一种模式（不关心具体是哪一种），你可以使用Dictionary.max(by:)，你可以用它来找到计数最高的（元素，计数）对（即dict值）。然后，你可以得到这对的键，这将是模式元素。

extension Sequence where Element: Hashable {
    func countOccurrences() -> [Element: Int] {
        return self.reduce(into: [:]) { (occurences, element) in occurences[element, default: 0] += 1}
    }

    func mode() -> Element? {
        return self.countOccurrences()
            .max(by: { $0.value < $1.value })?
            .key
    }

    func modes() -> [Element] {
        var firstModeNumOccurences: Int? = nil
        let modes = countOccurrences()
            .sorted { pairA, pairB in pairA.value > pairB.value } // sorting in descending order of num occurences
            .lazy
            .prefix(while:) { (_, numOccurences) in
                if firstModeNumOccurences == nil { firstModeNumOccurences = numOccurences }
                return numOccurences == firstModeNumOccurences
            }
            .map { (element, _) in element }

        return Array(modes)
    }
}

print([1, 2, 3, 3, 4, 4].mode() as Any) // => 3 or 4, non-deterministic
print([1, 2, 3, 3, 4, 4].modes() as Any) // => [3, 4]