在数组中的对象上使用过滤器查找最大值？ [迅速]

Question

我有一堆存储在数组中的对象。

它们都具有以下属性：

distanceInSeconds: Int

我想知道是否有办法使用过滤器或其他数组方法在数组的所有对象之间找到此属性的最大值？

例如：

var distances: [Distance] = []
var maxDistance = distances.filter(find max)

Answer 1

这将是快速的方式（通过实现Comparable ）：

class Route : Comparable {
    let distance: Int

    init(distance: Int) {
        self.distance = distance
    }
}

func ==(lhs: Route, rhs: Route) -> Bool {
    return lhs.distance == rhs.distance
}

func <(lhs: Route, rhs: Route) -> Bool {
    return lhs.distance < rhs.distance
}

let routes = [
    Route(distance: 4),
    Route(distance: 8),
    Route(distance: 2),
    Route(distance: 7)
]

print(routes.maxElement()?.distance)

输出：

"8"

这适用于maxElement(routes) 。如果您使用的是Swift 1.2，则maxElement(routes)应该可以工作

Answer 2

在Swift 2.0中，minElement和maxElement现在在序列为空的情况下返回可选值，并且现在也具有采用isOrderedBefore闭包的版本。

    let maxDistance = distances.maxElement { (a, b) -> Bool in
        a.distanceInSeconds < b.distanceInSeconds
    }

Answer 3

我想你要减少：

设定：

struct Distance {
    var distanceInSeconds: Int
}

var distances: [Distance] = []
for _ in 1...10 {
    distances += [Distance(distanceInSeconds: Int(arc4random_uniform(100)))]
}

实现方式：

let max = distances.reduce(distances.first) {
    if let left = $0 where left.distanceInSeconds > $1.distanceInSeconds {
        return $0
    } else {
        return $1
    }
}

Answer 4

＃1 序列内的元素类型符合Comparable协议

使用Swift 4，如果序列中的元素类型符合Comparable协议，则可以使用具有以下声明的max()方法：

func max() -> Self.Element?

返回序列中的最大元素。

用法：

class Distance: Comparable, CustomStringConvertible {

    let distanceInSeconds: Int
    var description: String { return "Distance in Int: \(distanceInSeconds)" }

    init(distanceInSeconds: Int) {
        self.distanceInSeconds = distanceInSeconds
    }

    static func ==(lhs: Distance, rhs: Distance) -> Bool {
        return lhs.distanceInSeconds == rhs.distanceInSeconds
    }

    static func <(lhs: Distance, rhs: Distance) -> Bool {
        return lhs.distanceInSeconds < rhs.distanceInSeconds
    }

}

let distances = [
    Distance(distanceInSeconds: 20),
    Distance(distanceInSeconds: 30),
    Distance(distanceInSeconds: 10)
]

let maxDistance = distances.max()
print(String(describing: maxDistance)) // prints: Optional(Distance in Int: 30)

---

＃2。 序列内的元素类型不符合Comparable协议

在Swift 4中，如果序列中的元素类型不符合Comparable协议，则必须使用具有以下声明的max(by:)方法：

func max(by areInIncreasingOrder: ((offset: Int, element: Base.Element), (offset: Int, element: Base.Element)) throws -> Bool) rethrows -> (offset: Int, element: Base.Element)?

使用给定的谓词作为元素之间的比较，返回序列中的最大元素。

用法：

class Distance: CustomStringConvertible {

    let distanceInSeconds: Int
    var description: String { return "Distance in Int: \(distanceInSeconds)" }

    init(distanceInSeconds: Int) {
        self.distanceInSeconds = distanceInSeconds
    }

}

let distances = [
    Distance(distanceInSeconds: 20),
    Distance(distanceInSeconds: 30),
    Distance(distanceInSeconds: 10)
]

let maxDistance = distances.max (by: { (a, b) -> Bool in
    return a.distanceInSeconds < b.distanceInSeconds
})

print(String(describing: maxDistance)) // prints: Optional(Distance in Int: 30)