রুবিতে অ্যারে থেকে সদৃশ উপাদানগুলি সরান

Question

আমার একটি রুবি অ্যারে রয়েছে যাতে নকল উপাদান রয়েছে।

array = [1,2,2,1,4,4,5,6,7,8,5,6]

লুপ এবং পুনরুক্তি ব্যবহার না করে সমস্ত অনন্য উপাদান বজায় রেখে আমি কীভাবে এই অ্যারে থেকে সমস্ত নকল উপাদানগুলি সরিয়ে ফেলতে পারি?

Answer 1

array = array.uniq

uniq সমস্ত সদৃশ উপাদানগুলি সরায় এবং অ্যারের সমস্ত অনন্য উপাদান ধরে রাখে।

এটি রুবি ভাষার অনেক সুন্দরীর মধ্যে একটি।

Comments

না, ইউনিক! অ্যারেটি অনন্য হয়ে থাকলে পদ্ধতিটি শূন্য হবে: প্র: a = [1,2,3,4] a.uniq -> [1,2,3,4] তবে a.uniq! -> শূন্য

— duykhoa

আমি এটিকে রুবি ভাষার সৌন্দর্য হিসাবে দেখতে পাচ্ছি না ... এটি কেবল রুবি স্ট্যান্ডার্ড লাইব্রেরির সৌন্দর্য? আমাকে ভুল করবেন না, ভাষা সম্পর্কে অনেক সুন্দর জিনিস রয়েছে।

— জাস্টিন এল।

উদ্দেশ্য-সি, জাভাস্ক্রিপ্ট এবং পিএইচপি তে একই লিখুন। তাহলে আমাদের বলুন যে রুবি কোনও সুন্দর ভাষা নয়!

— অ্যাডাম ওয়েট

এটি জটিল ধরণের জন্যও কাজ করে: [{how: "are"}, {u:"doing"}, {how: "are"}].uniq => [{:how=>"are"}, {:u=>"doing"}]

— ব্লেস্কোভিচ

@ দুয়খোয়া কী বলে, ইউনিক! পদ্ধতিটি শূন্য করে দেয়, তবে আপনি সাধারণত কোনও ফেরতের বিষয়ে চিন্তা করেন না যা .uniq!এটি নিজেই কাজ করে

— carpinchosaurio

Answer 2

ছেদটি ফেরত দিতে পারেন।

a = [1,1,2,3]
a & a

এটি সদৃশও মুছে ফেলবে।

Comments

কার্যকরীভাবে, এই উত্তরটি সঠিক, তবে আমি মনে করি এটি কেবল ইউনিক ব্যবহারের চেয়ে কম কম পাঠযোগ্য।

— ফিয়োনা টি

আমি কেবল এটি এখানে রাখছিলাম তাই যে কেউ এই পৃষ্ঠাটিতে যান তিনি এটি করার অন্যান্য উপায়গুলিও দেখতে পাবেন, আমি এটি কোনওভাবেই ভাল বলে দেওয়ার চেষ্টা করছিলাম না।

— jaredsmith

এটি কাজ করার কারণটি হ'ল সেট অপারেশনগুলি ব্যবহার করার সময়, ফলস্বরূপ অ্যারেটিকে একটি সেট হিসাবে গণ্য করা হয় যা একটি ডেটা স্ট্রাকচার যা সাধারণত কোনও পুনরাবৃত্ত মান থাকে না। a | a(ইউনিয়ন) ব্যবহার করা একই কৌশল করে।

— সেজার

Answer 3

আপনি ইউনিট পদ্ধতিতে সদৃশ উপাদানগুলি মুছতে পারেন:

array.uniq  # => [1, 2, 4, 5, 6, 7, 8]

এটি জানার জন্য কী কার্যকর হতে পারে তা হ'ল এটি uniqএকটি ব্লক নেয়, সুতরাং আপনার যদি কীগুলির একটি অ্যারে থাকে:

["bucket1:file1", "bucket2:file1", "bucket3:file2", "bucket4:file2"]

এবং আপনি জানতে চান যে অনন্য ফাইলগুলি কী তা আপনি এটির সাথে এটি খুঁজে পেতে পারেন:

a.uniq { |f| f[/\d+$/] }.map { |p| p.split(':').last }

Comments

আমি এতে কিছুটা বিভ্রান্ত হয়ে পড়েছি। আপনার নিজের তুলনা ফাংশনের প্রয়োজন হলে ব্লকটি ব্যবহৃত হয় - উদাহরণস্বরূপ, uniqকোনও ব্লক ছাড়াই সেই অ্যারেতে প্রেরণ করা আপনার ব্লকের সাথে একই মানটি ফিরিয়ে আনবে।

— hdgarrood

Answer 4

কেউ যদি যত্ন করে তবেই অন্য একটি বিকল্প।

আপনি to_setঅ্যারের পদ্ধতিটিও ব্যবহার করতে পারেন যা অ্যারেটিকে একটি সেটে রূপান্তর করে এবং সংজ্ঞা অনুসারে, সেট উপাদানগুলি অনন্য।

[1,2,3,4,5,5,5,6].to_set => [1,2,3,4,5,6]

Comments

আপনি যদি মেমরির বিষয়ে চিন্তা করেন তবে to_set4 টি অবজেক্ট বরাদ্দ দেবেন, যখন একটি uniqবরাদ্দ করে।

— জানু ক্লিমো

Answer 5

যদি কেউ পুনরাবৃত্তি মানগুলির সমস্ত দৃষ্টান্তগুলি সরানোর কোনও উপায় সন্ধান করে তবে দেখুন " আমি কীভাবে দক্ষতার সাথে রুবি অ্যারেতে পুনরাবৃত্তি করা উপাদানগুলি বের করতে পারি? " দেখুন।

a = [1, 2, 2, 3]
counts = Hash.new(0)
a.each { |v| counts[v] += 1 }
p counts.select { |v, count| count == 1 }.keys # [1, 3]

Comments

বা সহজভাবে করতে পারে a = [1, 2, 2, 3] a.find_all { |x| a.count(x) == 1 } # [1, 3]

— টিম রাইট

লিঙ্কযুক্ত প্রশ্নটি এক নয়; এটি অনুরূপ মানগুলি কীভাবে সন্ধান করতে এবং সেগুলি ফিরিয়ে আনতে জিজ্ঞাসা করছে। ওপি সদৃশগুলি সরাতে চায়।

— টিন ম্যান

Answer 6

কিছুটা অন্তর্দৃষ্টি দেওয়ার জন্য:

require 'fruity'
require 'set'

array = [1,2,2,1,4,4,5,6,7,8,5,6] * 1_000

def mithun_sasidharan(ary)
  ary.uniq
end

def jaredsmith(ary)
  ary & ary
end

def lri(ary)
  counts = Hash.new(0)
  ary.each { |v| counts[v] += 1 }
  counts.select { |v, count| count == 1 }.keys 
end

def finks(ary)
  ary.to_set
end

def santosh_mohanty(ary)
    result = ary.reject.with_index do |ele,index|
      res = (ary[index+1] ^ ele)
      res == 0
    end
end

SHORT_ARRAY = [1,1,2,2,3,1]
mithun_sasidharan(SHORT_ARRAY) # => [1, 2, 3]
jaredsmith(SHORT_ARRAY) # => [1, 2, 3]
lri(SHORT_ARRAY) # => [3]
finks(SHORT_ARRAY) # => #<Set: {1, 2, 3}>
santosh_mohanty(SHORT_ARRAY) # => [1, 2, 3, 1]

puts 'Ruby v%s' % RUBY_VERSION

compare do
  _mithun_sasidharan { mithun_sasidharan(array) }
  _jaredsmith { jaredsmith(array) }
  _lri { lri(array) }
  _finks { finks(array) }
  _santosh_mohanty { santosh_mohanty(array) }
end

যা, যখন চালানো হয় ফলাফল:

# >> Ruby v2.7.1
# >> Running each test 16 times. Test will take about 2 seconds.
# >> _mithun_sasidharan is faster than _jaredsmith by 2x ± 0.1
# >> _jaredsmith is faster than _santosh_mohanty by 4x ± 0.1 (results differ: [1, 2, 4, 5, 6, 7, 8] vs [1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, ...
# >> _santosh_mohanty is similar to _lri (results differ: [1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, ...
# >> _lri is similar to _finks (results differ: [] vs #<Set: {1, 2, 4, 5, 6, 7, 8}>)

দ্রষ্টব্য: এইগুলি খারাপ ফলাফলগুলি ফিরিয়ে দিয়েছে:

• lri(SHORT_ARRAY) # => [3]
• finks(SHORT_ARRAY) # => #<Set: {1, 2, 3}>
• santosh_mohanty(SHORT_ARRAY) # => [1, 2, 3, 1]

Answer 7

অন্তর্নির্মিত ফাংশনগুলি ব্যবহার না করেই XOR অপারেটরটি ব্যবহার করে দেখুন:

a = [3,2,3,2,3,5,6,7].sort!

result = a.reject.with_index do |ele,index|
  res = (a[index+1] ^ ele)
  res == 0
end

print result

অন্তর্নির্মিত ফাংশন সহ:

a = [3,2,3,2,3,5,6,7]

a.uniq

Comments

আমি ডাউনটোটেড হয়নি এবং আমি রুবি সম্পর্কে কিছুই জানিনা, তবে এটি .sort!কোনও ইনবিল্ট ফাংশনও নয়?

— ক্যারোলাস