arr तार की सरणी है:
["hello", "world", "stack", "overflow", "hello", "again"]यह देखने के लिए एक आसान और सुरुचिपूर्ण तरीका होगा कि क्या arrडुप्लिकेट है, और यदि हां, तो उनमें से एक को वापस करें (कोई फर्क नहीं पड़ता)?
उदाहरण:
["A", "B", "C", "B", "A"] # => "A" or "B"
["A", "B", "C"] # => nilजवाबों:
a = ["A", "B", "C", "B", "A"]
a.detect{ |e| a.count(e) > 1 }मुझे पता है कि यह बहुत ही सुंदर जवाब नहीं है, लेकिन मुझे यह पसंद है। यह सुंदर एक लाइनर कोड है। और पूरी तरह से ठीक काम करता है जब तक कि आपको विशाल डेटा सेट को संसाधित करने की आवश्यकता न हो।
तेजी से समाधान के लिए खोज रहे हैं? हेयर यू गो!
def find_one_using_hash_map(array)
map = {}
dup = nil
array.each do |v|
map[v] = (map[v] || 0 ) + 1
if map[v] > 1
dup = v
break
end
end
return dup
endयह रैखिक, O (n) है, लेकिन अब कई लाइनों का प्रबंधन करने की आवश्यकता है, कोड की जरूरत है, परीक्षण के मामले, आदि।
यदि आपको और भी तेज़ समाधान की आवश्यकता है, तो शायद इसके बजाय C आज़माएं।
और यहाँ विभिन्न समाधानों की तुलना करने वाला सार है: https://gist.github.com/naveed-ahmad/8f0b926ffccf5fbd206a1cc58ce9743e
a.select {|e| a.count(e) > 1}.uniq
आप इसे कुछ तरीकों से कर सकते हैं, पहला विकल्प सबसे तेज़ होने के साथ:
ary = ["A", "B", "C", "B", "A"]
ary.group_by{ |e| e }.select { |k, v| v.size > 1 }.map(&:first)
ary.sort.chunk{ |e| e }.select { |e, chunk| chunk.size > 1 }.map(&:first)और एक O (N ^ 2) विकल्प (यानी कम कुशल):
ary.select{ |e| ary.count(e) > 1 }.uniqgroup_by.select
ary.group_by(&:itself):। :-)
बस पहला उदाहरण ढूंढें जहां ऑब्जेक्ट का इंडेक्स (बाईं ओर से गिनती) ऑब्जेक्ट के इंडेक्स (दाएं से गिनती) के बराबर नहीं है।
arr.detect {|e| arr.rindex(e) != arr.index(e) }यदि कोई डुप्लिकेट नहीं हैं, तो रिटर्न मान शून्य होगा।
मेरा मानना है कि यह सबसे तेजी से समाधान सूत्र में अब तक, साथ ही तैनात है, क्योंकि यह अतिरिक्त ऑब्जेक्ट के निर्माण पर निर्भर नहीं करता है, और #indexऔर #rindexसी में लागू किया जाता है बड़ा-ओ क्रम एन ^ 2 है और इस तरह धीमी गति से सर्जियो, लेकिन दीवार का समय इस तथ्य के कारण बहुत तेज हो सकता है कि सी में "धीमी" भाग चलते हैं।
arr.find_all {|e| arr.rindex(e) != arr.index(e) }.uniq
arr.detect.with_index { |e, idx| idx != arr.rindex(e) }:। का उपयोग with_indexकर पहली indexखोज के लिए आवश्यकता को दूर करना चाहिए ।
detectकेवल एक डुप्लिकेट पाता है। find_allउन सभी को मिल जाएगा:
a = ["A", "B", "C", "B", "A"]
a.find_all { |e| a.count(e) > 1 }countसरणी में हर तत्व के लिए आह्वान करने के लिए बहुत ही अयोग्य है । जैसे, निर्माण, (ए गिनती हैश, उदाहरण के लिए, और अधिक कुशल है h = {"A"=>2, "B"=>2, "C"=> 1 }तो h.select { |k,v| v > 1 }.keys #=> ["A", "B"]।
यहां डुप्लिकेट खोजने के दो और तरीके हैं।
एक सेट का उपयोग करें
require 'set'
def find_a_dup_using_set(arr)
s = Set.new
arr.find { |e| !s.add?(e) }
end
find_a_dup_using_set arr
#=> "hello" सभी डुप्लिकेट की एक सरणी को वापस करने के selectस्थान पर उपयोग करें find।
उपयोग Array#difference
class Array
def difference(other)
h = other.each_with_object(Hash.new(0)) { |e,h| h[e] += 1 }
reject { |e| h[e] > 0 && h[e] -= 1 }
end
end
def find_a_dup_using_difference(arr)
arr.difference(arr.uniq).first
end
find_a_dup_using_difference arr
#=> "hello" .firstसभी डुप्लिकेट की एक सरणी वापस करने के लिए ड्रॉप करें।
nilयदि कोई डुप्लिकेट नहीं हैं, तो दोनों विधियाँ वापस आती हैं।
मैंने प्रस्ताव दिया किArray#difference रूबी कोर में जोड़ा जाए। अधिक जानकारी यहाँ मेरे उत्तर में है ।
बेंचमार्क
सुझाए गए तरीकों की तुलना करते हैं। सबसे पहले, हमें परीक्षण के लिए एक सरणी की आवश्यकता है:
CAPS = ('AAA'..'ZZZ').to_a.first(10_000)
def test_array(nelements, ndups)
arr = CAPS[0, nelements-ndups]
arr = arr.concat(arr[0,ndups]).shuffle
endऔर विभिन्न परीक्षण सरणियों के लिए मानदंड चलाने की एक विधि:
require 'fruity'
def benchmark(nelements, ndups)
arr = test_array nelements, ndups
puts "\n#{ndups} duplicates\n"
compare(
Naveed: -> {arr.detect{|e| arr.count(e) > 1}},
Sergio: -> {(arr.inject(Hash.new(0)) {|h,e| h[e] += 1; h}.find {|k,v| v > 1} ||
[nil]).first },
Ryan: -> {(arr.group_by{|e| e}.find {|k,v| v.size > 1} ||
[nil]).first},
Chris: -> {arr.detect {|e| arr.rindex(e) != arr.index(e)} },
Cary_set: -> {find_a_dup_using_set(arr)},
Cary_diff: -> {find_a_dup_using_difference(arr)}
)
endमैंने @ JjP के उत्तर को शामिल नहीं किया क्योंकि केवल एक डुप्लिकेट वापस करना है, और जब उसका उत्तर यह करने के लिए संशोधित किया जाता है कि यह @ नवेद के पहले वाले उत्तर के समान है। न ही मैंने @ मारिन के उत्तर को शामिल किया, जिसने @ नवेद के उत्तर से पहले पोस्ट किया, केवल एक के बजाय सभी डुप्लिकेट लौटाए (एक मामूली बिंदु लेकिन दोनों का मूल्यांकन करने वाला कोई बिंदु नहीं है, क्योंकि वे एक ही नकल करते समय समान हैं)।
मैंने अन्य उत्तरों को भी संशोधित किया है जो सभी डुप्लिकेट्स को वापस लौटाते हैं जो केवल पहले वाले को मिला है, लेकिन इसका प्रदर्शन पर अनिवार्य रूप से कोई प्रभाव नहीं होना चाहिए, क्योंकि उन्होंने एक का चयन करने से पहले सभी डुप्लिकेट की गणना की थी।
प्रत्येक बेंचमार्क के परिणाम सबसे तेज़ से सबसे धीमे सूचीबद्ध हैं:
पहले मान लें कि सरणी में 100 तत्व हैं:
benchmark(100, 0)
0 duplicates
Running each test 64 times. Test will take about 2 seconds.
Cary_set is similar to Cary_diff
Cary_diff is similar to Ryan
Ryan is similar to Sergio
Sergio is faster than Chris by 4x ± 1.0
Chris is faster than Naveed by 2x ± 1.0
benchmark(100, 1)
1 duplicates
Running each test 128 times. Test will take about 2 seconds.
Cary_set is similar to Cary_diff
Cary_diff is faster than Ryan by 2x ± 1.0
Ryan is similar to Sergio
Sergio is faster than Chris by 2x ± 1.0
Chris is faster than Naveed by 2x ± 1.0
benchmark(100, 10)
10 duplicates
Running each test 1024 times. Test will take about 3 seconds.
Chris is faster than Naveed by 2x ± 1.0
Naveed is faster than Cary_diff by 2x ± 1.0 (results differ: AAC vs AAF)
Cary_diff is similar to Cary_set
Cary_set is faster than Sergio by 3x ± 1.0 (results differ: AAF vs AAC)
Sergio is similar to Ryanअब 10,000 तत्वों के साथ एक सरणी पर विचार करें:
benchmark(10000, 0)
0 duplicates
Running each test once. Test will take about 4 minutes.
Ryan is similar to Sergio
Sergio is similar to Cary_set
Cary_set is similar to Cary_diff
Cary_diff is faster than Chris by 400x ± 100.0
Chris is faster than Naveed by 3x ± 0.1
benchmark(10000, 1)
1 duplicates
Running each test once. Test will take about 1 second.
Cary_set is similar to Cary_diff
Cary_diff is similar to Sergio
Sergio is similar to Ryan
Ryan is faster than Chris by 2x ± 1.0
Chris is faster than Naveed by 2x ± 1.0
benchmark(10000, 10)
10 duplicates
Running each test once. Test will take about 11 seconds.
Cary_set is similar to Cary_diff
Cary_diff is faster than Sergio by 3x ± 1.0 (results differ: AAE vs AAA)
Sergio is similar to Ryan
Ryan is faster than Chris by 20x ± 10.0
Chris is faster than Naveed by 3x ± 1.0
benchmark(10000, 100)
100 duplicates
Cary_set is similar to Cary_diff
Cary_diff is faster than Sergio by 11x ± 10.0 (results differ: ADG vs ACL)
Sergio is similar to Ryan
Ryan is similar to Chris
Chris is faster than Naveed by 3x ± 1.0ध्यान दें कि find_a_dup_using_difference(arr)अगर बहुत अधिक कुशल होगाArray#difference C में लागू किया गया था, तो यह होगा, अगर यह रूबी कोर में जोड़ा जाता है तो मामला होगा।
निष्कर्ष
जवाब में से कई उचित हैं लेकिन सेट का उपयोग करना सबसे अच्छा विकल्प है । यह मध्यम-कठिन मामलों में सबसे तेज है, संयुक्त सबसे कठिन और केवल कम्प्यूटेशनल रूप से तुच्छ मामलों में - जब आपकी पसंद वैसे भी कोई फर्क नहीं पड़ेगा - क्या इसे पीटा जा सकता है।
एक बहुत विशेष मामला जिसमें आप क्रिस के समाधान को चुन सकते हैं, यदि आप हजारों छोटे सरणियों को अलग-अलग डी-डुप्लिकेट करने के लिए विधि का उपयोग करना चाहते हैं और आमतौर पर 10 से कम आइटमों में डुप्लिकेट खोजने की अपेक्षा करते हैं। यह थोड़ा तेज होगा। क्योंकि यह सेट बनाने के छोटे अतिरिक्त ओवरहेड से बचा जाता है।
काश अधिकांश उत्तर हैं O(n^2)।
यहाँ एक O(n)समाधान है,
a = %w{the quick brown fox jumps over the lazy dog}
h = Hash.new(0)
a.find { |each| (h[each] += 1) == 2 } # => 'the"इसकी जटिलता क्या है?
O(n)पहले मैच में रन और ब्रेकO(n)मेमोरी का उपयोग करता है, लेकिन केवल न्यूनतम राशिअब, आपके सरणी में कितनी बार डुप्लिकेट हैं, इसके आधार पर ये रनटाइम वास्तव में और भी बेहतर हो सकते हैं। उदाहरण के लिए यदि आकार की सरणी को अलग-अलग तत्वों O(n)की आबादी से नमूना किया गया है, k << nकेवल रनटाइम और स्पेस दोनों के लिए जटिलता बन जाती है O(k), हालांकि यह अधिक संभावना है कि मूल पोस्टर इनपुट को मान्य कर रहा है और यह सुनिश्चित करना चाहता है कि कोई डुप्लिकेट न हों। उस स्थिति में, रनटाइम और मेमोरी की जटिलता, O(n)क्योंकि हम उम्मीद करते हैं कि तत्वों में इनपुट के बहुमत के लिए कोई पुनरावृत्ति न हो।
रूबी एरे वस्तुओं में एक महान विधि है select,।
select {|item| block } → new_ary
select → an_enumeratorपहला रूप यह है कि आप यहाँ क्या रुचि रखते हैं। यह आपको उन वस्तुओं का चयन करने की अनुमति देता है जो एक परीक्षा पास करते हैं।
रूबी एरे वस्तुओं में एक और विधि है count,।
count → int
count(obj) → int
count { |item| block } → intइस मामले में, आप डुप्लिकेट में रुचि रखते हैं (ऑब्जेक्ट जो कि सरणी में एक से अधिक बार दिखाई देते हैं)। उचित परीक्षण है a.count(obj) > 1।
अगर है a = ["A", "B", "C", "B", "A"]तो
a.select{|item| a.count(item) > 1}.uniq
=> ["A", "B"]आप कहते हैं कि आप केवल एक वस्तु चाहते हैं । तो एक को उठाओ।
["A", "B", "B", "A"]
.uniqसरणी पर रखने के लिए एक संपादन प्रस्तुत किया है ।
countसरणी के प्रत्येक तत्व के लिए आह्वान करते हैं, जो बेकार और अनावश्यक है। JjP के जवाब पर मेरी टिप्पणी देखें।
find_all () देता है एक arrayसभी तत्वों वाली enumके लिए जो blockनहीं है false।
duplicateतत्वों को प्राप्त करने के लिए
>> arr = ["A", "B", "C", "B", "A"]
>> arr.find_all { |x| arr.count(x) > 1 }
=> ["A", "B", "B", "A"]या डुप्लिकेट uniqतत्व
>> arr.find_all { |x| arr.count(x) > 1 }.uniq
=> ["A", "B"] कुछ इस तरह काम करेगा
arr = ["A", "B", "C", "B", "A"]
arr.inject(Hash.new(0)) { |h,e| h[e] += 1; h }.
select { |k,v| v > 1 }.
collect { |x| x.first }यही है, सभी मानों को हैश में रखें जहां कुंजी सरणी का तत्व है और मूल्य घटनाओं की संख्या है। फिर उन सभी तत्वों का चयन करें जो एक से अधिक बार होते हैं। आसान।
मुझे पता है कि यह धागा विशेष रूप से रूबी के बारे में है, लेकिन मैं यहां यह देखने के लिए उतरा कि इस तरह से रूबी के संदर्भ में ActiveRecord के साथ कैसे किया जाए और मुझे लगा कि मैं अपना समाधान भी साझा करूंगा।
class ActiveRecordClass < ActiveRecord::Base
#has two columns, a primary key (id) and an email_address (string)
end
ActiveRecordClass.group(:email_address).having("count(*) > 1").count.keysउपरोक्त सभी ईमेल पतों की एक सरणी है जो इस उदाहरण के डेटाबेस तालिका में डुप्लिकेट किए गए हैं (जो कि रेल में "active_record_classes" होगा)।
a = ["A", "B", "C", "B", "A"]
a.each_with_object(Hash.new(0)) {|i,hash| hash[i] += 1}.select{|_, count| count > 1}.keysयह है एक O(n) प्रक्रिया है।
वैकल्पिक रूप से आप निम्न पंक्तियों में से कोई भी कर सकते हैं। इसके अलावा ओ (एन) लेकिन केवल एक पुनरावृत्ति
a.each_with_object(Hash.new(0).merge dup: []){|x,h| h[:dup] << x if (h[x] += 1) == 2}[:dup]
a.inject(Hash.new(0).merge dup: []){|h,x| h[:dup] << x if (h[x] += 1) == 2;h}[:dup]यहां मेरा डेटा के एक बड़े सेट पर इस तरह से लेना है - जैसे कि डुप्लीकेट भागों को खोजने के लिए एक विरासत dBase तालिका
# Assuming ps is an array of 20000 part numbers & we want to find duplicates
# actually had to it recently.
# having a result hash with part number and number of times part is
# duplicated is much more convenient in the real world application
# Takes about 6 seconds to run on my data set
# - not too bad for an export script handling 20000 parts
h = {};
# or for readability
h = {} # result hash
ps.select{ |e|
ct = ps.count(e)
h[e] = ct if ct > 1
}; nil # so that the huge result of select doesn't print in the consoleeach_with_object आपका दोस्त है!
input = [:bla,:blubb,:bleh,:bla,:bleh,:bla,:blubb,:brrr]
# to get the counts of the elements in the array:
> input.each_with_object({}){|x,h| h[x] ||= 0; h[x] += 1}
=> {:bla=>3, :blubb=>2, :bleh=>2, :brrr=>1}
# to get only the counts of the non-unique elements in the array:
> input.each_with_object({}){|x,h| h[x] ||= 0; h[x] += 1}.reject{|k,v| v < 2}
=> {:bla=>3, :blubb=>2, :bleh=>2}यह कोड डुप्लिकेटेड मानों की सूची लौटाएगा। हैश कीज़ को जाँचने के एक कुशल तरीके के रूप में उपयोग किया जाता है, जो पहले ही देखे जा चुके हैं। इस आधार पर कि क्या मूल्य देखा गया है, मूल सरणी aryको 2 सरणियों में विभाजित किया गया है: पहला जिसमें अद्वितीय मूल्य हैं और दूसरा डुप्लिकेट है।
ary = ["hello", "world", "stack", "overflow", "hello", "again"]
hash={}
arr.partition { |v| hash.has_key?(v) ? false : hash[v]=0 }.last.uniq
=> ["hello"]आप इसे और संक्षिप्त कर सकते हैं - यद्यपि इस रूप में थोड़ा और अधिक जटिल वाक्य रचना की लागत पर:
hash={}
arr.partition { |v| !hash.has_key?(v) && hash[v]=0 }.last.uniqa = ["A", "B", "C", "B", "A"]
b = a.select {|e| a.count(e) > 1}.uniq
c = a - b
d = b + cपरिणाम
d
=> ["A", "B", "C"]यदि आप दो अलग-अलग सरणियों (खुद के खिलाफ एक के बजाय) की तुलना कर रहे हैं, तो रूबी के ऐरे वर्ग& द्वारा प्रदान किए गए प्रतिच्छेद ऑपरेटर का उपयोग करना बहुत तेज़ तरीका है ।
# Given
a = ['a', 'b', 'c', 'd']
b = ['e', 'f', 'c', 'd']
# Then this...
a & b # => ['c', 'd']मुझे यह पता लगाने की आवश्यकता है कि कितने डुप्लिकेट थे और वे क्या थे इसलिए मैंने एक समारोह लिखा था जिसमें नावेद ने पहले पोस्ट किया था:
def print_duplicates(array)
puts "Array count: #{array.count}"
map = {}
total_dups = 0
array.each do |v|
map[v] = (map[v] || 0 ) + 1
end
map.each do |k, v|
if v != 1
puts "#{k} appears #{v} times"
total_dups += 1
end
end
puts "Total items that are duplicated: #{total_dups}"
endआइए कोड कार्यान्वयन में प्रदर्शित करते हैं
def duplication given_array
seen_objects = []
duplication_objects = []
given_array.each do |element|
duplication_objects << element if seen_objects.include?(element)
seen_objects << element
end
duplication_objects
endअब दोहराव विधि और आउटपुट रिटर्न परिणाम को कॉल करें -
dup_elements = duplication [1,2,3,4,4,5,6,6]
puts dup_elements.inspect
[1,2,3].uniq!.nil? => true
[1,2,3,3].uniq!.nil? => false
ऊपर नोटिस विनाशकारी है
arr == arr.uniqयह देखने के लिए एक आसान और सुरुचिपूर्ण तरीका होगा किarrक्या डुप्लिकेट हैं, हालांकि, यह प्रदान नहीं करता है जो डुप्लिकेट थे।