मैं रूबी 1.8.6 का उपयोग रेल 1.2.3 के साथ कर रहा हूं, और यह निर्धारित करने की आवश्यकता है कि क्या दो सरणियों में समान तत्व हैं, चाहे वे एक ही क्रम में हों या नहीं। सरणियों में से एक को डुप्लिकेट (अन्य का जवाब नहीं है, जिस स्थिति में उत्तर नहीं है) को शामिल नहीं करने की गारंटी है।
मेरा पहला विचार था
require 'set'
a.to_set == b.to_set
लेकिन मैं सोच रहा था कि क्या ऐसा करने का एक अधिक कुशल या मुहावरेदार तरीका था।
[1,2]और [2,1,1]एक ही तत्व हैं?)
differenceजो बहुत तेज और बहुत पठनीय दोनों का समाधान प्रदान करता है। अधिक जानकारी यहाँ।
जवाबों:
इसे सेट करने के लिए रूपांतरण की आवश्यकता नहीं है:
a.sort == b.sort
.uniq.sortफिर क्या है ? इसके अलावा आंतरिक रूप से अतिरिक्त के uniqसमान हैto_set.to_a.sort
uniq। वास्तव में मैंने एक के साथ एक सरणियों का निर्माण किया Range#to_a, इसलिए मेरे पास केवल sortदूसरे के लिए था ।
दो सरणियों ए और बी के लिए: ए और बी में एक ही सामग्री है यदि:
(A-B).blank? and (B-A).blank?
या आप बस इसके लिए जाँच कर सकते हैं:
((A-B) + (B-A)).blank?
जैसा कि @ cort3z द्वारा सुझाया गया है यह समाधान als0 बहुरूपी सरणियों के लिए काम करता है
A = [1 , "string", [1,2,3]]
B = [[1,2,3] , "string", 1]
(A-B).blank? and (B-A).blank? => true
# while A.uniq.sort == B.uniq.sort will throw error `ArgumentError: comparison of Fixnum with String failed`
:::::::::: EDIT :::::::::::::
जैसा कि टिप्पणियों में सुझाव दिया गया है, उपरोक्त समाधान डुप्लिकेट के लिए विफल रहता है। हालांकि सवाल के अनुसार भी आवश्यक नहीं है, क्योंकि पूछने वाले को डुप्लिकेट में कोई दिलचस्पी नहीं है (वह चेक करने से पहले सेट करने के लिए अपने सरणियों को परिवर्तित कर रहा है और वह नकल करता है और भले ही आप देखें जवाब देने से पहले वह एक .unq ऑपरेटर का उपयोग कर रहा है और वह भी नकल करता है।)। लेकिन फिर भी अगर आपकी रुचि डुप्लिकेट है, तो बस गिनती की जांच को जोड़ने से एक ही तय हो जाएगा (प्रश्न के अनुसार केवल एक सरणी में डुप्लिकेट हो सकते हैं)। तो अंतिम समाधान होगा:
A.size == B.size and ((A-B) + (B-A)).blank?
A=[1]और B=[1,1], दोनों (A-B)और (B-A)खाली वापस आ जाएगी। सरणी दस्तावेज़ देखें ।
a.to_set == b.to_set और स्वीकृत उत्तर का उपयोग कर रहा है a.uniq.sort == b.uniq.sortऔर दोनों ((A-B) + (B-A)).blank?A = [1] के समान सटीक परिणाम देते हैं। और बी = [११ ९] सहमत हैं? चूंकि वह सिर्फ अपने मूल समाधान पर सुधार के लिए पूछ रहा था, मेरा मूल समाधान अभी भी काम करता है :)। इस बात से सहमत?
A = [123, "test", [], some_object, nil]और B = A#because I am lazyफिर A.uniq.sortत्रुटि (स्ट्रिंग और ऐरे की तुलना में विफल) फेंक देंगे।
A = [1, 1, 2]औरB = [1, 2, 2]
गति की बाध्यता
require 'benchmark/ips'
require 'set'
a = [1, 2, 3, 4, 5, 6]
b = [1, 2, 3, 4, 5, 6]
Benchmark.ips do |x|
x.report('sort') { a.sort == b.sort }
x.report('sort!') { a.sort! == b.sort! }
x.report('to_set') { a.to_set == b.to_set }
x.report('minus') { ((a - b) + (b - a)).empty? }
end
Warming up --------------------------------------
sort 88.338k i/100ms
sort! 118.207k i/100ms
to_set 19.339k i/100ms
minus 67.971k i/100ms
Calculating -------------------------------------
sort 1.062M (± 0.9%) i/s - 5.389M in 5.075109s
sort! 1.542M (± 1.2%) i/s - 7.802M in 5.061364s
to_set 200.302k (± 2.1%) i/s - 1.006M in 5.022793s
minus 783.106k (± 1.5%) i/s - 3.942M in 5.035311s
sortहै गति
to_setबड़े पर्याप्त सरणियों के साथ बेहतर प्रदर्शन शुरू करने की उम्मीद करूंगा जहां ओ (एन लोगन) सेट करने के लिए सरणी को परिवर्तित करने के लिए आवश्यक प्रयास से अधिक
रूबी 2.6+
रूबी ने difference2.6 में पेश किया।
यह एक बहुत तेज, बहुत पठनीय समाधान यहाँ देता है, इस प्रकार है:
a = [1, 2, 3, 4, 5, 6]
b = [1, 2, 3, 4, 5, 6]
a.difference(b).any?
# => false
a.difference(b.reverse).any?
# => false
a = [1, 2, 3, 4, 5, 6]
b = [1, 2, 3]
a.difference(b).any?
# => true
बेंचमार्क चलाना:
a = Array.new(1000) { rand(100) }
b = Array.new(1000) { rand(100) }
Benchmark.ips do |x|
x.report('sort') { a.sort == b.sort }
x.report('sort!') { a.sort! == b.sort! }
x.report('to_set') { a.to_set == b.to_set }
x.report('minus') { ((a - b) + (b - a)).empty? }
x.report('difference') { a.difference(b).any? }
end
sort 13.908k (± 2.6%) i/s - 69.513k in 5.001443s
sort! 14.656k (± 3.0%) i/s - 73.736k in 5.035744s
to_set 5.125k (± 2.9%) i/s - 26.023k in 5.082083s
minus 16.398k (± 2.2%) i/s - 83.181k in 5.074938s
difference 27.839k (± 5.2%) i/s - 141.048k in 5.080706s
आशा है कि किसी की मदद करता है!
जब के तत्वों aऔर bकर रहे हैं Comparable,
a.sort == b.sort
@ मोरी के जवाब का सुधार @ स्टेन्सलैग की टिप्पणी के आधार पर
aऔर bहल किया जा सकता है।
यदि आप उम्मीद करते हैं कि [:a, :b] != [:a, :a, :b] to_setकाम नहीं करेगा। आप इसके बजाय आवृत्ति का उपयोग कर सकते हैं:
class Array
def frequency
p = Hash.new(0)
each{ |v| p[v] += 1 }
p
end
end
[:a, :b].frequency == [:a, :a, :b].frequency #=> false
[:a, :b].frequency == [:b, :a].frequency #=> true
a.sort == b.sortअगर वह आवृत्ति के बारे में परवाह है?
["", :b].frequency == [:b, ""].frequency #=> true
a.group_by{|i| i} == b.group_by{|i| i}
यदि आप जानते हैं कि सरणियाँ समान लंबाई की हैं और न ही सरणी में डुप्लिकेट हैं तो यह भी काम करता है:
( array1 & array2 ) == array1
स्पष्टीकरण:& इस मामले में ऑपरेटर a1 बिना की एक प्रति किसी भी आइटम a2 में नहीं मिला है, जो मूल a1 रूप में ही है iff दोनों सरणियों कोई डुप्लिकेट के साथ एक ही सामग्री है देता है।
विश्लेषण: यह देखते हुए कि आदेश अपरिवर्तित है, मुझे लगता है कि यह एक दोहरे पुनरावृत्ति के रूप में कार्यान्वित किया जाता है लगातार O(n*n), विशेष रूप से अन्य सरणियों के लिए इससे भी बदतरa1.sort == a2.sort जो सबसे खराब स्थिति के साथ प्रदर्शन करना चाहिए O(n*logn)।
a1 = [1,2,3], a2 = [2, 1, 3] a1 && a2रिटर्न [2,1,3]जो बराबर नहीं हैa1
a1==a2? यह काम कर सकता है यदि array1समानता के दाईं ओर से प्रतिस्थापित किया जाता है array2, लेकिन मुझे संदेह है कि तत्वों द्वारा लौटाए गए आदेश की &गारंटी है।
&सरणियों के लिए एक सेट चौराहे ऑपरेटर है, &&तार्किक है और वे बहुत अलग हैं!
संयोजन &और sizeतेजी से भी हो सकता है।
require 'benchmark/ips'
require 'set'
Benchmark.ips do |x|
x.report('sort') { a.sort == b.sort }
x.report('sort!') { a.sort! == b.sort! }
x.report('to_set') { a.to_set == b.to_set }
x.report('minus') { ((a - b) + (b - a)).empty? }
x.report('&.size') { a.size == b.size && (a & b).size == a.size }
end
Calculating -------------------------------------
sort 896.094k (±11.4%) i/s - 4.458M in 5.056163s
sort! 1.237M (± 4.5%) i/s - 6.261M in 5.071796s
to_set 224.564k (± 6.3%) i/s - 1.132M in 5.064753s
minus 2.230M (± 7.0%) i/s - 11.171M in 5.038655s
&.size 2.829M (± 5.4%) i/s - 14.125M in 5.010414s
एक दृष्टिकोण डुप्लिकेट के साथ सरणी पर पुनरावृति करना है
# assume array a has no duplicates and you want to compare to b
!a.map { |n| b.include?(n) }.include?(false)
यह trues की एक सरणी देता है। अगर कोई झूठा दिखाई पड़ता है, तो बाहरी include?सच लौट आएगा। इस प्रकार आपको यह निर्धारित करने के लिए कि क्या यह एक मैच है, पूरी तरह से पलटना होगा।