2016-04-19 5 views
20

के वहाँ दो सरणियों हैं मान लीजिए ...स्विफ्ट में मैं कैसे जांचूं यदि दो सरणी में वही तत्व होते हैं, चाहे वे तत्व किस क्रम में दिखाई देते हैं?

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

मैं इन दो सरणियों की तुलना का परिणाम चाहते हैं सच होना, और निम्न ...

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

.. झूठी होने के लिए। स्विफ्ट में मैं इसे कैसे प्राप्त कर सकता हूं? मैंने सेट करने के लिए दोनों सरणी को कन्वर्ट करने की कोशिश की लेकिन कुछ कारणों से सेट() सरणी में कुछ (आमतौर पर डुप्लिकेट) ऑब्जेक्ट्स को हटा देता रहता है।

किसी भी मदद की सराहना की जाएगी।

+2

के बारे में क्या '[" एक "," बी "]' और '[" एक "," एक "," ख "] ', क्या उन्हें' सत्य 'या' झूठी 'की तुलना करनी चाहिए? – dasblinkenlight

+0

झूठा, लेकिन ["ए", "ए", "बी"] और ["ए", "बी", "ए"] सत्य के रूप में। –

+4

बस टिप्पणी करने के लिए - "... लेकिन किसी कारण से सेट() कुछ (आमतौर पर डुप्लीकेट) ऑब्जेक्ट्स को हटाता रहता है" - हाँ, ऐसा इसलिए है, * परिभाषा * द्वारा, सेट में डुप्लिकेट नहीं होते हैं। –

उत्तर

34

स्विफ्ट 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

बहुत अच्छा, शायद मैं पहले तत्वों को सॉर्ट करने के विचार के साथ नहीं आऊंगा। जवाब देने वाले हर किसी के लिए धन्यवाद। –

4

आप कुछ इस तरह कर सकते हैं:

array1.sortInPlace() 
    array2.sortInPlace() 

    print(array1,array2) 

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

और अगर मूल सरणी बदल नहीं करना चाहती हम

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

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

समारोह बनाएं उनकी तुलना करने के:

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

तब:

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

आम तौर पर एक बुलियन चेक को इसके तर्कों को म्यूट नहीं करना चाहिए। – OrangeDog

+0

आपका क्या मतलब है? – Khuong

+0

ओह, मुझे अब याद है, स्विफ्ट में सरणी के लिए मानसिक कॉलिंग सम्मेलन हैं। – OrangeDog

संबंधित मुद्दे