Comment puis-je vérifier dans Swift si deux tableaux contiennent les mêmes éléments quel que soit l'ordre dans lequel les éléments apparaissent dans?

Disons qu'il y a deux tableaux...

var array1 = ["a", "b", "c"]
var array2 = ["b", "c", "a"]

J'aimerais que le résultat de la comparaison de ces deux tableaux soit vrai, et ce qui suit...

var array1 = ["a", "b", "c"]
var array2 = ["b", "c", "a", "d"]

... être faux. Comment puis-je y parvenir dans Swift? J'ai essayé de convertir les deux tableaux en ensembles, mais pour une raison quelconque, Set () continue de supprimer certains objets (généralement dupliqués) que le tableau contient.

Toute aide serait appréciée.

26
demandé sur Gerwazy Sokołowski 2016-04-19 12:40:16

5 réponses

Swift 3, 4

extension Array where Element: Comparable {
    func containsSameElements(as other: [Element]) -> Bool {
        return self.count == other.count && self.sorted() == other.sorted()
    }
}

// usage
let a: [Int] = [1, 2, 3, 3, 3]
let b: [Int] = [1, 3, 3, 3, 2]
let c: [Int] = [1, 2, 2, 3, 3, 3]

print(a.containsSameElements(as: b)) // true
print(a.containsSameElements(as: c)) // false
48
répondu Alexander Doloz 2017-08-28 19:06:07

Vous pouvez faire quelque chose comme ceci:

  array1.sortInPlace()
  array2.sortInPlace()

  print(array1,array2)

  if array1 == array2 {
    print("equal")
  } else {
  print("not equal") 
  }

Et si vous ne voulez pas changer le tableau d'origine, nous pouvons faire 

 let sorted1 = array1.sort()
 let sorted2 = array2.sort()

  if sorted1 == sorted2 {
    print("equal")
  }else {
    print("not equal")
  }
4
répondu Sahil 2016-04-19 10:00:37

Créer une fonction pour les comparer: 

func containSameElements(var firstArray firstArray: [String], var secondArray: [String]) -> Bool {
    if firstArray.count != secondArray.count {
        return false
    } else {
        firstArray.sortInPlace()
        secondArray.sortInPlace()
        return firstArray == secondArray
    }
}

Puis: 

var array1 = ["a", "a", "b"]
var array2 = ["a", "b", "a"]

var array3 = ["a", "b", "c"]
var array4 = ["b", "c", "a", "d"]

print(containSameElements(firstArray: array1, secondArray: array2)) //true
print(containSameElements(firstArray: array3, secondArray: array4)) //false
print(array1) //["a", "a", "b"]
print(array2) //["a", "b", "a"]
print(array3) //["a", "b", "c"]
print(array4) //["b", "c", "a", "d"]
2
répondu Khuong 2016-04-19 10:28:29

Voici une solution qui ne nécessite pas l'élément Comparable, mais seulement Equatable. C'est beaucoup moins efficace que les réponses de tri, donc si votre type peut être rendu Comparable, utilisez l'un de ceux-ci.

extension Array where Element: Equatable {
    func equalContents(to other: [Element]) -> Bool {
        guard self.count == other.count else {return false}
        for e in self{
          guard self.filter{$0==e}.count == other.filter{$0==e}.count else {
            return false
          }
        }
        return true
    }
}
1
répondu Asa Zeren 2018-05-06 21:18:25

Solution pour Swift 4.1 / Xcode 9.4: 

extension Array where Element: Equatable {
    func containSameElements(_ array: [Element]) -> Bool {
        var selfCopy = self
        var secondArrayCopy = array
        while let currentItem = selfCopy.popLast() {
            if let indexOfCurrentItem = secondArrayCopy.index(of: currentItem) {
                secondArrayCopy.remove(at: indexOfCurrentItem)
            } else {
                return false
            }
        }
        return secondArrayCopy.isEmpty
    }
}

Le principal avantage de cette solution est qu'elle utilise moins de mémoire que les autres (elle ne crée toujours que 2 tableaux temporaires). Aussi, il ne nécessite pas de Element à Comparable, juste pour être Equatable.

0
répondu Roman Podymov 2018-07-17 09:25:51