prüfen Sie, ob alle Elemente eines Arrays den gleichen Wert haben in Swift

Jede Methode muss iterativ über alle Elemente, bis ein anderes element ist gefunden:

func allEqualUsingLoop<T : Equatable>(array : [T]) -> Bool {
    if let firstElem = array.first {
        for elem in array {
            if elem != firstElem {
                return false
            }
        }
    }
    return true
}

Statt eines expliziten Schleife können Sie die contains() Funktion:

func allEqualUsingContains<T : Equatable>(array : [T]) -> Bool {
    if let firstElem = array.first {
        return !contains(array, { $0 != firstElem })
    }
    return true
}

Wenn die array-Elemente sind Hashable (wie Int) dann können Sie
erstellen Sie eine Set (verfügbar seit Swift 1.2) von der array-Elemente und überprüfen, ob es genau ein element.

func allEqualUsingSet<T : Hashable>(array : [T]) -> Bool {
    let uniqueElements = Set(array)
    return count(uniqueElements) <= 1
}

Einen schnellen Benchmark test ergab, dass die "enthält" - Methode ist viel schneller als die "set" - Methode
für ein array von 1.000.000 ganzen zahlen, insbesondere, wenn die Elemente
nicht alle gleich. Dies ist sinnvoll, weil contains() kehrt so bald
als ein nicht übereinstimmendes element gefunden wird, in der Erwägung, dass Set(array) immer
durchläuft das gesamte array.

Auch die "enthält" - Methoden ist gleich schnell oder etwas schneller als eine explizite Schleife.

Hier ist einige einfache benchmarking-code. Natürlich können die Ergebnisse variieren
mit der array-Größe, die Anzahl der verschiedenen Elemente und die Elemente Datentyp.

func measureExecutionTime<T>(title: String,  @noescape f : (() -> T) ) -> T {
    let start = NSDate()
    let result = f()
    let end = NSDate()
    let duration = end.timeIntervalSinceDate(start)
    println("\(title) \(duration)")
    return result
}

var array = [Int](count: 1_000_000, repeatedValue: 1)
array[500_000] = 2

let b1 = measureExecutionTime("using loop    ") {
    return allEqualUsingLoop(array)
}

let b2 = measureExecutionTime("using contains") {
    allEqualUsingContains(array)
}

let b3 = measureExecutionTime("using set     ") {
    allEqualUsingSet(array)
}

Ergebnisse (auf einem MacBook Pro, Release-Konfiguration):

mit Schleife 0.000651001930236816 
die Verwendung enthält 0.000567018985748291 
mit set 0.0344770550727844 

Mit array[1_000] = 2 die Ergebnisse sind

mit Schleife 9.00030136108398 e-06 
die Verwendung enthält 2.02655792236328 e-06 
mit set 0.0306439995765686 

Update für Swift 2/Xcode 7: Aufgrund verschiedener änderungen in der Swift
syntax, die Funktion ist jetzt so geschrieben, wie

func allEqual<T : Equatable>(array : [T]) -> Bool {
    if let firstElem = array.first {
        return !array.dropFirst().contains { $0 != firstElem }
    }
    return true
}

Aber jetzt können Sie auch definieren es als eine Erweiterung-Methode für arrays:

extension Array where Element : Equatable {
    func allEqual() -> Bool {
        if let firstElem = first {
            return !dropFirst().contains { $0 != firstElem }
        }
        return true
    }
}

print([1, 1, 1].allEqual()) //true
print([1, 2, 1].allEqual()) // false

Swift-5 verwenden, können Sie eine der folgenden vier Möglichkeiten, um zu testet, ob alle Elemente eines Arrays gleich sind.

#1. Mit Array's allSatisfy(_:) Methode

allSatisfy(_:) gibt einen booleschen Wert zurück, der angibt, ob jedes element einer Sequenz erfüllt ein bestimmtes Prädikat. Sie können das Prädikat, um zu testen, ob alle Elemente des Arrays gleich sind:

let array = [1, 1, 1]

let hasAllItemsEqual = array.dropFirst().allSatisfy({ $0 == array.first })
print(hasAllItemsEqual) // prints: true

let array = [1, 1, 3]

let hasAllItemsEqual = array.dropFirst().allSatisfy({ $0 == array.first })
print(hasAllItemsEqual) // prints: false

let array = [Int]()

let hasAllItemsEqual = array.dropFirst().allSatisfy({ $0 == array.first })
print(hasAllItemsEqual) // prints: true

#2. Mit Array's reduce(_:_:) Methode

Als alternative zu allSatisfy(_:) verwenden, können Sie reduce(_:_:):

let array = [1, 1, 1]

let hasAllItemsEqual = array.dropFirst().reduce(true) { (partialResult, element) in
    return partialResult && element == array.first
}
print(hasAllItemsEqual) // prints: true

let array = [1, 1, 3]

let hasAllItemsEqual = array.dropFirst().reduce(true) { (partialResult, element) in
    return partialResult && element == array.first
}
print(hasAllItemsEqual) // prints: false

let array = [Int]()

let hasAllItemsEqual = array.dropFirst().reduce(true) { (partialResult, element) in
    return partialResult && element == array.first
}
print(hasAllItemsEqual) // prints: true

#3. Mit elementsEqual(_:) Methode

elementsEqual(_:) gibt einen booleschen Wert zurück, der angibt, ob zwei Sequenzen enthalten die gleichen Elemente in der gleichen Reihenfolge. Daher können Sie eine neue Sammlung erstellen, durch die Wiederholung das erste element des ersten array und vergleichen die erstere mit der letzteren:

let array = [1, 1, 1]

precondition(!array.isEmpty)
let repeated = repeatElement(array[0], count: array.count)

let hasAllItemsEqual = array.elementsEqual(repeated)
print(hasAllItemsEqual) // prints: true

let array = [1, 1, 3]

precondition(!array.isEmpty)
let repeated = repeatElement(array[0], count: array.count)

let hasAllItemsEqual = array.elementsEqual(repeated)
print(hasAllItemsEqual) // prints: false

#4. Mit Set's init(_:) initalizer

Wenn alle Elemente eines Arrays gleich sind, erstellen Sie einen Satz von diesem array soll in die festlegen, dass nur ein element:

let array = [1, 1, 1]

let set = Set(array)
let hasAllItemsEqual = set.count <= 1
print(hasAllItemsEqual) // prints: true

let array = [1, 1, 3]

let set = Set(array)
let hasAllItemsEqual = set.count <= 1
print(hasAllItemsEqual) // prints: false

let array = [Int]()

let set = Set(array)
let hasAllItemsEqual = set.count <= 1
print(hasAllItemsEqual) // prints: true