2016-04-19 9 views
20

Diciamo che ci sono due matrici ...Come faccio a verificare in Swift se due array contengono gli stessi elementi indipendentemente dall'ordine in cui appaiono quegli elementi?

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

mi piacerebbe il risultato del confronto di queste due matrici per essere vero, e la seguente ...

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

.. . essere falso Come posso ottenerlo in Swift? Ho provato a convertire entrambi gli array in serie, ma per qualche motivo Set() continua a rimuovere alcuni oggetti (di solito duplicati) contenuti nella matrice.

Qualsiasi aiuto sarebbe apprezzato.

+2

Che dire '[ "a", "b"]' e '[ "a", "a", "b"] ', dovrebbero confrontare' true' o 'false'? – dasblinkenlight

+0

Falso, ma ["a", "a", "b"] e ["a", "b", "a"] come veri. –

+4

Solo per commentare - "... ma per qualche motivo Set() continua a rimuovere alcuni oggetti (di solito duplicati)" - sì, perché, per * definizione *, gli insiemi non contengono duplicati. –

risposta

34

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 

+1

Molto bello, molto probabilmente non mi sarebbe venuta l'idea di ordinare prima gli elementi. Grazie a tutti quelli che hanno risposto. –

4

si può fare qualcosa di simile:

array1.sortInPlace() 
    array2.sortInPlace() 

    print(array1,array2) 

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

e se non si desidera cambiare matrice originale che può fare

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

    if sorted1 == sorted2 { 
    print("equal") 
    }else { 
    print("not equal") 
    } 
2

Crea una funzione per confrontarli:

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

Poi:

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"] 
+0

In genere un controllo booleano non deve mutare i suoi argomenti. – OrangeDog

+0

Cosa intendi? – Khuong

+0

Oh, mi ricordo ora, Swift ha convenzioni di chiamata mentale per gli array. – OrangeDog