Até agora, tenho uma maneira simples (mas potencialmente cara):

var myMax = sort(myArray,>)[0]

E como eu fui ensinado a fazer isso na escola:

var myMax = 0
for i in 0..myArray.count {
    if (myArray[i] > myMax){myMax = myArray[i]}
}

Existe uma maneira melhor de obter o valor máximo de uma matriz inteira no Swift? Idealmente, algo como uma linha como a de Ruby.max

Dado:

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

Swift 3:

numbers.min() // equals 1
numbers.max() // equals 5

Swift 2:

numbers.minElement() // equals 1
numbers.maxElement() // equals 5

Atualização: Essa provavelmente deve ser a resposta aceita desde que maxElementapareceu no Swift.

Use o Todo reduce- Poderoso :

let nums = [1, 6, 3, 9, 4, 6];
let numMax = nums.reduce(Int.min, { max($0, $1) })

Similarmente:

let numMin = nums.reduce(Int.max, { min($0, $1) })

reducepega um primeiro valor que é o valor inicial para uma variável interna do acumulador e aplica a função passada (aqui, é anônima) ao acumulador e a cada elemento da matriz sucessivamente, e armazena o novo valor no acumulador. O último valor do acumulador é retornado.

Com Swift 5, Array, assim como outros Sequenceobjectos conforme protocolo ( Dictionary, Set, etc), tem dois métodos de chamadas max()e max(by:)que o elemento de retorno máxima na sequência ou nilse a sequência está vazia.

# 1 Usando Arrayo max()método

Se o tipo de elemento dentro de seus conforma seqüência de Comparableprotocolo (que pode ser String, Float, Characterou um de sua classe personalizada ou struct), você vai ser capaz de usar max()que tem a seguinte declaração :

@warn_unqualified_access func max() -> Element?

Retorna o elemento máximo na sequência.

Os seguintes códigos do Playground são exibidos max():

let intMax = [12, 15, 6].max()
let stringMax = ["bike", "car", "boat"].max()

print(String(describing: intMax)) // prints: Optional(15)
print(String(describing: stringMax)) // prints: Optional("car")

class Route: Comparable, CustomStringConvertible {

    let distance: Int
    var description: String { return "Route with distance: \(distance)" }

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

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

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

}

let routes = [
    Route(distance: 20),
    Route(distance: 30),
    Route(distance: 10)
]

let maxRoute = routes.max()
print(String(describing: maxRoute)) // prints: Optional(Route with distance: 30)

# 2 Usando Arrayo max(by:)método

Se o tipo de elemento dentro da sua sequência não Comparableestiver em conformidade com o protocolo, você precisará usar max(by:)a seguinte declaração :

@warn_unqualified_access func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?

Retorna o elemento máximo na sequência, usando o predicado fornecido como comparação entre os elementos.

Os seguintes códigos do Playground são exibidos max(by:):

let dictionary = ["Boat" : 15, "Car" : 20, "Bike" : 40]

let keyMaxElement = dictionary.max(by: { (a, b) -> Bool in
    return a.key < b.key
})

let valueMaxElement = dictionary.max(by: { (a, b) -> Bool in
    return a.value < b.value
})

print(String(describing: keyMaxElement)) // prints: Optional(("Car", 20))
print(String(describing: valueMaxElement)) // prints: Optional(("Bike", 40))

class Route: CustomStringConvertible {

    let distance: Int
    var description: String { return "Route with distance: \(distance)" }

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

}

let routes = [
    Route(distance: 20),
    Route(distance: 30),
    Route(distance: 10)
]

let maxRoute = routes.max(by: { (a, b) -> Bool in
    return a.distance < b.distance
})

print(String(describing: maxRoute)) // prints: Optional(Route with distance: 30)

As outras respostas estão todas corretas, mas não esqueça que você também pode usar operadores de coleta, da seguinte maneira:

var list = [1, 2, 3, 4]
var max: Int = (list as AnyObject).valueForKeyPath("@max.self") as Int

você também pode encontrar a média da mesma maneira:

var avg: Double = (list as AnyObject).valueForKeyPath("@avg.self") as Double

Essa sintaxe pode ser menos clara do que algumas das outras soluções, mas é interessante ver que -valueForKeyPath:ainda pode ser usado :)

Você pode usar com reduce:

let randomNumbers = [4, 7, 1, 9, 6, 5, 6, 9]
let maxNumber = randomNumbers.reduce(randomNumbers[0]) { $0 > $1 ? $0 : $1 } //result is 9

var numbers = [1, 2, 7, 5];    
var val = sort(numbers){$0 > $1}[0];

Com o Swift 1.2 (e talvez antes), agora você precisa usar:

let nums = [1, 6, 3, 9, 4, 6];
let numMax = nums.reduce(Int.min, combine: { max($0, $1) })

Para trabalhar com valores Double, usei algo como isto:

let nums = [1.3, 6.2, 3.6, 9.7, 4.9, 6.3];
let numMax = nums.reduce(-Double.infinity, combine: { max($0, $1) })

No Swift 2.0, os métodos de protocolo minElemente maxElementtorne - se SequenceType, você deve chamá-los como:

let a = [1, 2, 3]
print(a.maxElement()) //3
print(a.minElement()) //1

Usar maxElementcomo uma função como nãomaxElement(a) está disponível agora.

A sintaxe do Swift está em fluxo, por isso posso confirmar isso no Xcode versão7 beta6 .

Pode ser modificado no futuro, então sugiro que você verifique melhor o documento antes de usar esses métodos.

Swift 3.0

Você pode tentar esse código programaticamente.

func getSmallAndGreatestNumber() -> Void {

    let numbers = [145, 206, 116, 809, 540, 176]
    var i = 0
    var largest = numbers[0]
    var small = numbers[0]
    while i < numbers.count{

        if (numbers[i] > largest) {
            largest = numbers[i]
        }
        if (numbers[i] < small) {
            small = numbers[i]
        }
        i = i + 1
    }
    print("Maximum Number ====================\(largest)")// 809
    print("Minimum Number ====================\(small)")// 116
}

Aqui está um teste de desempenho para as soluções postadas aqui. https://github.com/tedgonzalez/MaxElementInCollectionPerformance

Este é o mais rápido para o Swift 5

array.max()

Atualizado para Swift 3/4:

Use abaixo linhas simples de código para encontrar o máximo da matriz;

var num = [11, 2, 7, 5, 21]
var result = num.sorted(){
    $0 > $1
}
print("max from result: \(result[0])") // 21

Você também pode classificar sua matriz e, em seguida, usar array.firstouarray.last