Array erweitern, um zu prüfen, ob es in Swift sortiert ist?

Question

Ich möchte Array-Klasse erweitern, so dass es wissen kann, ob es sortiert ist (aufsteigend) oder nicht. Ich möchte eine berechnete Eigenschaft namens isSorted hinzufügen. Wie kann ich die Elemente des Arrays als vergleichbar bezeichnen?

Meine aktuelle Implementierung in Spielplatz

extension Array { 
    var isSorted: Bool { 
    for i in 1..self.count { 
     if self[i-1] > self[i] { return false } 
    } 
    return true 
    } 
} 

// The way I want to get the computed property 
[1, 1, 2, 3, 4, 5, 6, 7, 8].isSorted //= true 
[2, 1, 3, 8, 5, 6, 7, 4, 8].isSorted //= false 

Der FehlerCould not find an overload for '>' that accepts the supplied arguments

Natürlich, ich habe immer noch einen Fehler, da Swift nicht weiß, wie die Elemente miteinander zu vergleichen. Wie kann ich diese Erweiterung in Swift implementieren? Oder mache ich hier etwas falsch?

Answer 1

Die alternative Lösung zu einer freien Funktion ist, was Swift eingebauten in Array.sort und Array.sorted Methoden zu tun tun, und verlangen, dass Sie einen geeigneten Komparator an die Methode übergeben:

extension Array { 
    func isSorted(isOrderedBefore: (T, T) -> Bool) -> Bool { 
     for i in 1..<self.count { 
      if !isOrderedBefore(self[i-1], self[i]) { 
       return false 
      } 
     } 
     return true 
    } 
} 

[1, 5, 3].isSorted(<) // false 
[1, 5, 10].isSorted(<) // true 
[3.5, 2.1, -5.4].isSorted(>) // true 

Answer 2

Sie haben ein Problem mit Swifts Generika, die nicht so gelöst werden können, wie Sie es gerade mögen (vielleicht in einer zukünftigen Swift-Version). Siehe auch Swift Generics issue.

Derzeit benötigen Sie eine Funktion (zum Beispiel im globalen Bereich) zu definieren:

func isSorted<T: Comparable>(array: Array<T>) -> Bool { 
    for i in 1..<array.count { 
     if array[i-1] > array[i] { 
      return false 
     } 
    } 

    return true 
} 

let i = [1, 2, 3] 
let j = [2, 1, 3] 
let k = [UIView(), UIView()] 
println(isSorted(i)) // Prints "true" 
println(isSorted(j)) // Prints "false" 
println(isSorted(k)) // Error: Missing argument for parameter #2 in call 

Die Fehlermeldung irreführend ist, IMHO, da der tatsächliche Fehler ist etwas wie „UIView nicht Erfüllen Sie die Typ-Constraint Comparable ".

Answer 3

In Swift 2.0 können Sie jetzt Protokolle erweitern!

extension CollectionType where Generator.Element: Comparable { 

    public var isSorted: Bool { 

     var previousIndex = startIndex 
     var currentIndex = startIndex.successor() 

     while currentIndex != endIndex { 

      if self[previousIndex] > self[currentIndex] { 
       return false 
      } 

      previousIndex = currentIndex 
      currentIndex = currentIndex.successor() 
     } 

     return true 
    } 

} 

[1, 2, 3, 4].isSorted // true 
["a", "b", "c", "e"].isSorted // true 
["b", "a", "c", "e"].isSorted // false 
[/* Anything not implementing `Comparable` */].isSorted // <~~ Type-error 

Beachten Sie, dass, weil wir Indexable.Index anstelle eines einfachen Int als Index verwenden wir stattdessen eine while-Schleife verwenden müssen, die ein bisschen weniger schön und klar aussieht.

Answer 4

Die flexibelste Lösung für mich ist eine Kombination aus NSAddict und Wes Campaignes Antwort. I.e. kombinieren den Vorteil, Protokolle erweitern zu können und Komparatorfunktionen als Argumente zu übergeben. Dies beseitigt die Einschränkungen sowohl für die Verwendung nur mit Arrays als auch für die Beschränkung auf Elemente, die dem Protokoll Comparable entsprechen.

extension CollectionType 
{ 
    func isSorted(isOrderedBefore: (Generator.Element, Generator.Element) -> Bool) -> Bool 
    { 
     var previousIndex = startIndex 
     var currentIndex = startIndex.successor() 

     while currentIndex != endIndex 
     { 
      if isOrderedBefore(self[previousIndex], self[currentIndex]) == false 
      { 
       return false 
      } 

      previousIndex = currentIndex 
      currentIndex = currentIndex.successor() 
     } 

     return true 
    } 
} 

Dies kann auf jede Collection Art und Sortierkriterien verwendet werden können nach Ihren Bedürfnissen definiert werden.