vérifier si tous les éléments d'un tableau ont la même valeur dans Swift

Toute méthode doit itérer sur tous les éléments jusqu'à ce qu'un autre élément est trouvé:

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

Au lieu d'une volonté explicite de la boucle, vous pouvez utiliser le contains() fonction:

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

Si les éléments du tableau sont Hashable (comme Int), alors vous pouvez
créer un Set (disponible depuis Swift 1.2) de la matrice d'éléments et de vérifier si elle a exactement un seul élément.

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

Une rapide analyse comparative de test a révélé que la "contient" la méthode est beaucoup plus rapide que la méthode
pour un tableau de 1 000 000 d'entiers, en particulier si les éléments sont
pas tous égaux. Ce sens parce que contains() retourne dès
en tant que non-élément correspondant n'est trouvé, alors que Set(array) toujours
parcourt l'ensemble de la matrice.

Également la "contient" méthodes est aussi rapide ou légèrement plus rapide qu'un explicite de la boucle.

Ici est une simple analyse comparative de code. Bien sûr, les résultats peuvent varier
avec la taille de la matrice, le nombre de différents éléments et les éléments de type de données.

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)
}

Des résultats (sur un MacBook Pro, la Libération de configuration):

à l'aide de la boucle 0.000651001930236816 
l'aide contient 0.000567018985748291 
l'aide de jeu de 0.0344770550727844 

Avec array[1_000] = 2 les résultats sont

à l'aide de la boucle 9.00030136108398 e-06 
l'aide contient 2.02655792236328 e-06 
l'aide de jeu de 0.0306439995765686 

---

Mise à jour pour Swift 2/Xcode 7: en Raison de divers changements dans la Swift
la syntaxe, la fonction est désormais rédigé comme

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

Mais désormais, vous pouvez également le définir comme une méthode d'extension pour les tableaux:

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

Avec Swift 5, vous pouvez utiliser l'une des quatre manières suivantes pour les tests, si tous les éléments d'un tableau sont égaux.

---

#1. À l'aide de Array's allSatisfy(_:) méthode

allSatisfy(_:) renvoie une valeur Booléenne indiquant si chaque élément d'une séquence répond à un prédicat. Vous pouvez définir le prédicat de tester si tous les éléments de la matrice sont égales:

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. À l'aide de Array's réduire(_:_:) méthode

Comme une alternative à allSatisfy(_:), vous pouvez utiliser 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. À l'aide de elementsEqual(_:) méthode

elementsEqual(_:) renvoie une valeur Booléenne indiquant si les deux séquences contiennent les mêmes éléments dans le même ordre. Par conséquent, vous pouvez créer une nouvelle collection en répétant le premier élément de la table initiale et de comparer l'ancien avec le dernier:

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. À l'aide de Set's init(_:) initalizer

Si tous les éléments d'un tableau sont l'égalité, la création d'un ensemble à partir de ce tableau devraient aboutir dans le jeu de n'avoir qu'un seul élément:

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