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
এটি লিনিয়ার, ও (এন), তবে এখন একাধিক লাইন অফ-কোড পরিচালনা করা দরকার, পরীক্ষার কেসগুলি ইত্যাদি দরকার needs
আপনার যদি আরও দ্রুত সমাধানের প্রয়োজন হয় তবে তার পরিবর্তে সি চেষ্টা করুন।
এবং এখানে বিভিন্ন সমাধানের সাথে তুলনা করার মূল বক্তব্যটি রয়েছে: 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)
এবং একটি ও (এন ^ 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 এবং এর চেয়ে ধীর সার্জিও'র, তবে "ধীর" অংশগুলি সি-তে চালিত হওয়ার কারণে প্রাচীরের সময়টি আরও দ্রুত হতে পারে could
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
আমি @ জেজেপির উত্তরটি অন্তর্ভুক্ত করি নি কারণ কেবলমাত্র একটি সদৃশ ফিরতে হবে এবং যখন তার উত্তরটি পরিবর্তন করতে হবে এটি @ নাভিদের আগের উত্তর হিসাবে একই same আমি @ মারিনের উত্তরও অন্তর্ভুক্ত করিনি, যা @ নাভিদের উত্তরের আগে পোস্ট করা হয়েছিল, কেবলমাত্র একটির চেয়ে সমস্ত নকলই ফেরত দিয়েছিল (একটি ছোট বিষয় তবে উভয়কেই মূল্যায়ন করার মতো কোনও বিষয় নেই, কারণ কেবলমাত্র একটি সদৃশ ফেরত দেওয়ার সময় তারা অভিন্ন)।
আমি অন্যান্য উত্তরগুলিও সংশোধন করেছিলাম যা পাওয়া গেছে কেবলমাত্র প্রথমটি পাওয়া যায় এবং ফিরে আসার জন্য সমস্ত অনুলিপি ফিরে এসেছিল, তবে এটির মূলত কোনও কার্যকারিতার উপর কোনও প্রভাব ফেলতে হবে না, কারণ তারা একটি নির্বাচন করার আগে সমস্ত নকলকে গণনা করেছিল।
প্রতিটি বেঞ্চমার্কের ফলাফলগুলি দ্রুত থেকে ধীরতম পর্যন্ত তালিকাভুক্ত করা হয়:
প্রথম ধরুন অ্যারেতে 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হবে, এটি রুবি কোরকে যুক্ত করা হলে এমন হবে।
উপসংহার
উত্তরগুলির অনেকগুলি যুক্তিসঙ্গত তবে একটি সেট ব্যবহার করা স্পষ্ট সেরা পছন্দ । এটি মাঝারি-হার্ড ক্ষেত্রে সবচেয়ে দ্রুত, সবচেয়ে কঠিন মধ্যে যৌথ দ্রুত এবং কেবল গণনামূলকভাবে তুচ্ছ ক্ষেত্রে - যখন আপনার পছন্দটি কোনওভাবেই গুরুত্ব দেয় না - এটি মারধর করা যেতে পারে।
আপনি ক্রিসের সমাধানটি বেছে নিতে পারেন তার মধ্যে একটি বিশেষ ক্ষেত্রে হ'ল আপনি যদি হাজার হাজার ছোট অ্যারে আলাদাভাবে ডি-নকল করতে পদ্ধতিটি ব্যবহার করতে চান এবং 10 টিরও কম আইটেম খুব সহজেই খুঁজে পাবেন This এটি কিছুটা দ্রুত হবে This এটি সেট তৈরির ক্ষেত্রে অতিরিক্ত অতিরিক্ত ওভারহেড এড়িয়ে চলে।
হায় হ'ল বেশিরভাগ উত্তর 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অ্যারের প্রতিটি উপাদানটির জন্য অনুরোধ করেন যা অপব্যয় এবং অপ্রয়োজনীয়। জেজেপির উত্তরে আমার মন্তব্য দেখুন।
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 }এটি হ্যাশে সমস্ত মান রাখুন যেখানে কীটি অ্যারের উপাদান এবং মান হ'ল সংখ্যার উপস্থিতি। তারপরে একাধিকবার উপস্থিত সমস্ত উপাদান নির্বাচন করুন। সহজ।
আমি জানি যে এই থ্রেডটি বিশেষত রুবির সম্পর্কে, তবে আমি কীভাবে এটি অ্যাক্টিভেকর্ডের সাথে রিলে অন প্রসঙ্গে রেখেছি এবং কীভাবে আমার সমাধানটি ভাগ করে নেব তা ভেবে আমি এখানে অবতরণ করেছি।
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উপরেরটি সমস্ত ইমেল ঠিকানাগুলির একটি অ্যারে প্রদান করে যা এই উদাহরণের ডাটাবেস সারণীতে নকল করা আছে (যা রেলের মধ্যে "সক্রিয়_আরেকর্ড_ক্ল্যাশস" হবে)।
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]এখানে আমার বড় অঙ্কের ডেটা গ্রহণ করা - যেমন সদৃশ অংশগুলি খুঁজে পাওয়ার জন্য কোনও উত্তরাধিকারী ডিবেস টেবিল
# 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}এই কোডটি সদৃশ মানগুলির তালিকা ফিরিয়ে দেবে। হ্যাশ কীগুলি কোন মানগুলি ইতিমধ্যে দেখা গেছে তা যাচাই করার কার্যকর উপায় হিসাবে ব্যবহৃত হয়। মানটি দেখা গেছে কিনা তার উপর ভিত্তি করে, মূল অ্যারেটি ary2 অ্যারেতে বিভক্ত করা হয়েছে: প্রথমে অনন্য মান রয়েছে এবং দ্বিতীয়টি সদৃশ রয়েছে।
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.uniqarrসদৃশগুলি আছে কিনা তা যাচাই করার জন্য একটি সহজ এবং মার্জিত উপায় হতে পারে , তবে এটি সদৃশ ছিল যা সরবরাহ করে না।