রুবিতে কোন অ্যারেতে কোনও মান বিদ্যমান আছে কিনা তা কীভাবে পরীক্ষা করবেন

Question

আমার একটি মান 'Dog'এবং একটি অ্যারে রয়েছে ['Cat', 'Dog', 'Bird']।

এটি কীভাবে লুপ না করে অ্যারেতে উপস্থিত রয়েছে তা আমি কীভাবে চেক করব? মান উপস্থিত আছে কিনা তা যাচাই করার একটি সহজ উপায় আছে, আরও কিছু নেই?

Comments

ব্যবহার .include? পদ্ধতি । এটি এমন একটি বুলিয়ান দেয় যা আপনি চান। আপনার ক্ষেত্রে কেবল টাইপ করুন: ['বিড়াল', 'কুকুর', 'পাখি'] include অন্তর্ভুক্ত করুন ('কুকুর') এবং এটি বুলিয়ান সত্য হিসাবে ফিরে আসবে।

— Jwan622

ব্যবহার অন্তর্ভুক্ত না? পদ্ধতিটি যদি আপনি অ্যারে উপস্থিত থাকতে বিভিন্ন মানের জন্য বহুবার পরীক্ষা করতে চান তবে অন্তর্ভুক্ত না কেন? প্রতিবার অনুসন্ধানের জন্য ও (এন) অপারেশন গ্রহণ করে অ্যারের উপরে পুনরাবৃত্তি হবে, পরিবর্তে একটি হ্যাশ তৈরি করুন hash = arr.map {|x| [x,true]}.to_h, এখন hash.has_key? 'Dog' সত্যটি ফিরে আসে কি না তা পরীক্ষা করে দেখুন

— akfaridi

আপনি সত্যই এটি "সম্পূর্ণরূপে লুপিং ছাড়াই" করতে পারবেন না। এটি যৌক্তিকভাবে অসম্ভব, কম্পিউটার কেবল এটি নিশ্চিতভাবে জানতে পারে না যে অ্যারে উপাদানগুলির লুপিং ব্যতীত উপাদান রয়েছে কিনা তা পরীক্ষা করে দেখার জন্য যে এর মধ্যে কোনওটি অনুসন্ধান করছে। অবশ্যই এটি খালি না হলে অবশ্যই। তারপরে আমার ধারণা আপনার কোনও লুপের দরকার নেই।

— টিম এম

অ্যারে এবং সেটে কোনও উপাদান খুঁজে বের করার বিভিন্ন উপায়ের পার্থক্যের পরীক্ষার জন্য নীচের মানদণ্ডগুলি দেখুন। stackoverflow.com/a/60404934/128421

— টিন ম্যান

Answer 1

আপনি খুঁজছেন include?:

>> ['Cat', 'Dog', 'Bird'].include? 'Dog'
=> true

Comments

বিকল্প বাক্য গঠন:%w(Cat Dog Bird).include? 'Dog'

— স্কার্ভার 2

কখনও কখনও আমি এটি "অন্তর্ভুক্ত" অন্তর্ভুক্ত না ইচ্ছুক। আমি সর্বদা এটির সাথে মিশে যাই।

— হেনলি চিউ

আমাকে কেবল এটি নোট করি যে অভ্যন্তরীণভাবে #include?এখনও লুপিং সম্পাদন করে। কোডার স্পষ্টভাবে লুপটি লেখা থেকে রক্ষা পেয়েছে। আমি একটি উত্তর যুক্ত করেছি যা লুপ ছাড়াই কার্য সম্পাদন করে।

— বরিস স্ট্যাটনিকি

@ হেনলিচিউ আমি যেটিকে বলা হয়েছিল[ 'Dog', 'Bird', 'Cat' ].has? 'Dog'

@ অ্যালফোনসো ভার্গারা হ্যাঁ, অ্যারের কোনও সমাধানের জন্য অভ্যন্তরীণভাবে কিছু লুপিং করতে হবে; লুপ ছাড়াই কোনও অ্যারের সদস্যতার জন্য পরীক্ষার কোনও উপায় নেই। আপনি যদি অভ্যন্তরীণভাবেও কোনও লুপিং করতে না চান তবে আপনাকে আলাদা ডেটা স্ট্রাকচার ব্যবহার করতে হবে, যেমন স্থির আকারের কীগুলির সাথে একটি নিখুঁত হ্যাশ টেবিল। অভ্যন্তরীণভাবে লুপ না করে অ্যারেতে সদস্যতার জন্য পরীক্ষা করার উপায় নেই বলে আমি এই প্রশ্নের ব্যাখ্যা দিয়েছি "স্পষ্টতই নিজে নিজে লুপটি না লিখে"

— ব্রায়ান ক্যাম্পবেল

Answer 2

@ ক্যাম্পাটারসন দ্বারা নির্দেশিত হিসাবে v3.1 সাল থেকে (রেলের অংশ) একটি in?পদ্ধতি রয়েছে ActiveSupport। সুতরাং কারাগারের মধ্যে বা require 'active_support'আপনি যদি লিখতে পারেন তবে:

'Unicorn'.in?(['Cat', 'Dog', 'Bird']) # => false

OTOH, রুবি নিজেই কোনও inঅপারেটর বা #in?পদ্ধতি নেই , যদিও এটি আগে প্রস্তাবিত হয়েছিল, বিশেষত ইউসুক এন্ডোহ রুবি-কোরের শীর্ষস্থানীয় সদস্য।

হিসাবে অন্যদের দ্বারা নির্দিষ্ট, বিপরীত পদ্ধতি include?বিদ্যমান, সবার জন্য Enumerableসহ গুলি Array, Hash, Set, Range:

['Cat', 'Dog', 'Bird'].include?('Unicorn') # => false

---

মনে রাখবেন যে আপনার অ্যারেতে যদি অনেকগুলি মান থাকে তবে সেগুলি একের পর এক (অর্থাত্ O(n)) পরীক্ষা করা হবে, যখন একটি হ্যাশের জন্য অনুসন্ধানটি স্থির সময় (অর্থাত্ O(1)) হবে। সুতরাং আপনি যদি অ্যারে স্থির থাকে, উদাহরণস্বরূপ, পরিবর্তে একটি সেট ব্যবহার করা ভাল ধারণা । উদাহরণ:

require 'set'
ALLOWED_METHODS = Set[:to_s, :to_i, :upcase, :downcase
                       # etc
                     ]

def foo(what)
  raise "Not allowed" unless ALLOWED_METHODS.include?(what.to_sym)
  bar.send(what)
end

একটি দ্রুত পরীক্ষা প্রকাশ করে যে include?10 টি উপাদানকে Setকল করা সমমানের দিকে কল করার চেয়ে প্রায় 3.5x গতিযুক্ত Array(যদি উপাদানটি খুঁজে পাওয়া যায় না)।

একটি চূড়ান্ত সমাপ্তি নোট: include?একটি ব্যবহার করার সময় সতর্ক থাকুন Range, সূক্ষ্মতা রয়েছে, সুতরাং ডকটি দেখুন এবং এর সাথে তুলনা করুন cover?...

Comments

যদিও রুবি #in?এর মূল অংশটি অন্তর্ভুক্ত করছে না, আপনি যদি রেলগুলি ব্যবহার করেন তবে এটি উপলব্ধ। api.rubyonrails.org/classes/Object.html#method-i-in-3F (আমি জানি এটি একটি রুবি, একটি কারাগারের প্রশ্ন নয়, তবে এটি কারও কাছে রেলগুলিতে ব্যবহার করতে সাহায্য করতে পারে L#in? মনে হচ্ছে এটি রেলগুলিতে যুক্ত হয়েছিল) 3.1 apidock.com/rails/Object/in%3F

— ক্যাম্পেটারসন

Answer 3

চেষ্টা

['Cat', 'Dog', 'Bird'].include?('Dog')

Comments

এটি পুরানো বাক্য গঠন, দেখুন

— b

@ জহরিচি আপনি এই উত্তরে "পুরানো বাক্য গঠন" ঠিক কী বিবেচনা করছেন, alচ্ছিক বন্ধনী?

— ডেনিস

আমি ডেনিসকে সম্মত করছি, এটি কোনও পুরানো নয়, বন্ধনীগুলি alচ্ছিক এবং বেশিরভাগ ক্ষেত্রে একটি ভাল অনুশীলন .... উদাহরণস্বরূপ বাক্যটি যদি একটি লাইনে বন্ধনী ছাড়াই অন্তর্ভুক্ত করে ব্যবহার করার চেষ্টা করুন তবে আমার অর্থ হ'ল আপনার মামলার উপর নির্ভর করে আপনি বা বন্ধনী ব্যবহার করা উচিত বা না ("পুরানো" রুবি সিনট্যাক্সের সাথে মোটেই সম্পর্কিত নয়)

— d1jhoni1b

এটিই কেবলমাত্র একটি সিনট্যাক্স যা আমি টের্নারি অপারেশনের মধ্যে কাজ করতে পারি।

— মাইকেল ক্যামেরন

Answer 4

ব্যবহার Enumerable#include:

a = %w/Cat Dog Bird/

a.include? 'Dog'

বা, যদি বেশ কয়েকটি পরীক্ষা করা হয়, ^{1 টি} আপনি লুপ থেকে মুক্তি পেতে পারেন (এটি এমনকি include?রয়েছে) এবং ও (এন) থেকে ও (1) এর সাথে যেতে পারেন:

h = Hash[[a, a].transpose]
h['Dog']

---

^{১. আমি আশা করি এটি সুস্পষ্ট তবে আপত্তি উপেক্ষা করার জন্য: হ্যাঁ, মাত্র কয়েকটি অনুসন্ধানের জন্য হ্যাশ [] এবং ট্রান্সপোজ অপস প্রোফাইলটিতে আধিপত্য বিস্তার করেছে এবং প্রতিটি ও ( ও ) নিজেরাই।}

Answer 5

আপনি যদি একটি ব্লক দিয়ে চেক করতে চান, আপনি চেষ্টা করতে পারেন any?বা all?।

%w{ant bear cat}.any? {|word| word.length >= 3}   #=> true  
%w{ant bear cat}.any? {|word| word.length >= 4}   #=> true  
[ nil, true, 99 ].any?                            #=> true  

আরও তথ্যের জন্য পরিসংখ্যান দেখুন ।

আমার অনুপ্রেরণাটি এসেছে " অ্যারে রুবিতে কোনও আইটেম থাকলে মূল্যায়ন করুন "

Comments

খুব কার্যকর যদি আপনি চান যে কোনও / সমস্ত স্ট্রিং অন্য স্ট্রিং / ধ্রুবক

— থানিক্কল

Answer 6

অ্যারেতে উপাদান খুঁজে পেতে রুবিয়ের এগারোটি পদ্ধতি রয়েছে।

include?পছন্দসইটি হ'ল বা, বারবার অ্যাক্সেসের জন্য একটি সেট তৈরি করুন এবং তারপরে কল করুন include?বাmember? ।

তাদের সব এখানে:

array.include?(element) # preferred method
array.member?(element)
array.to_set.include?(element)
array.to_set.member?(element)
array.index(element) > 0
array.find_index(element) > 0
array.index { |each| each == element } > 0
array.find_index { |each| each == element } > 0
array.any? { |each| each == element }
array.find { |each| each == element } != nil
array.detect { |each| each == element } != nil

trueউপাদান উপস্থিত থাকলে তারা সকলেই একটি ইশ মান প্রদান করে।

include?পছন্দসই পদ্ধতি। এটি forঅভ্যন্তরীণভাবে সি-ভাষার লুপ ব্যবহার করে যা কোনও উপাদান অভ্যন্তরীণ rb_equal_opt/rb_equalফাংশনগুলির সাথে মিলে গেলে বিরতি দেয়। আপনি পুনরাবৃত্ত সদস্যতার পরীক্ষার জন্য একটি সেট তৈরি না করলে এটি আরও বেশি দক্ষ হতে পারে না।

VALUE
rb_ary_includes(VALUE ary, VALUE item)
{
  long i;
  VALUE e;

  for (i=0; i<RARRAY_LEN(ary); i++) {
    e = RARRAY_AREF(ary, i);
    switch (rb_equal_opt(e, item)) {
      case Qundef:
        if (rb_equal(e, item)) return Qtrue;
        break;
      case Qtrue:
        return Qtrue;
    }
  }
  return Qfalse;
}

member?Arrayক্লাসে নতুন সংজ্ঞা দেওয়া হয়নি এবং Enumerableমডিউল থেকে একটি নিরবচ্ছিন্ন বাস্তবায়ন ব্যবহার করে যা আক্ষরিকভাবে সমস্ত উপাদানগুলির মাধ্যমে অঙ্কিত হয়:

static VALUE
member_i(RB_BLOCK_CALL_FUNC_ARGLIST(iter, args))
{
  struct MEMO *memo = MEMO_CAST(args);

  if (rb_equal(rb_enum_values_pack(argc, argv), memo->v1)) {
    MEMO_V2_SET(memo, Qtrue);
    rb_iter_break();
  }
  return Qnil;
}

static VALUE
enum_member(VALUE obj, VALUE val)
{
  struct MEMO *memo = MEMO_NEW(val, Qfalse, 0);

  rb_block_call(obj, id_each, 0, 0, member_i, (VALUE)memo);
  return memo->v2;
}

রুবি কোড অনুবাদিত এটি নিম্নলিখিত সম্পর্কে:

def member?(value)
  memo = [value, false, 0]
  each_with_object(memo) do |each, memo|
    if each == memo[0]
      memo[1] = true 
      break
    end
  memo[1]
end

উভয় include?এবংmember? ও (এন) সময় জটিলতা রয়েছে যেহেতু উভয়ই প্রত্যাশিত মানটির প্রথম উপস্থিতির জন্য অ্যারেটি অনুসন্ধান করে।

আমরা প্রথমে অ্যারের উপস্থাপনের জন্য একটি হ্যাশ প্রতিনিধিত্ব তৈরি করতে ব্যয় করে ও (1) অ্যাক্সেস সময় পাওয়ার জন্য একটি সেট ব্যবহার করতে পারি। আপনি যদি বারবার একই অ্যারেতে সদস্যতা পরীক্ষা করেন তবে এই প্রাথমিক বিনিয়োগটি দ্রুত পরিশোধ করতে পারে। Setসি তে প্রয়োগ করা হয়নি তবে প্লেইন রুবি শ্রেণি হিসাবে এখনও অন্তর্নিহিত এর ও (1) অ্যাক্সেস সময়@hash এটিকে সার্থক করে তোলে।

এখানে সেট শ্রেণীর বাস্তবায়ন:

module Enumerable
  def to_set(klass = Set, *args, &block)
    klass.new(self, *args, &block)
  end
end

class Set
  def initialize(enum = nil, &block) # :yields: o
    @hash ||= Hash.new
    enum.nil? and return
    if block
      do_with_enum(enum) { |o| add(block[o]) }
    else
      merge(enum)
    end
  end

  def merge(enum)
    if enum.instance_of?(self.class)
      @hash.update(enum.instance_variable_get(:@hash))
    else
      do_with_enum(enum) { |o| add(o) }
    end
    self
  end

  def add(o)
    @hash[o] = true
    self
  end

  def include?(o)
    @hash.include?(o)
  end
  alias member? include?

  ...
end

আপনি দেখতে পাচ্ছেন যে সেট শ্রেণিটি কেবল একটি অভ্যন্তরীণ @hashউদাহরণ তৈরি করে , এতে সমস্ত বস্তু ম্যাপ করেtrueHash#include? , হ্যাশ ক্লাসে ও (1) অ্যাক্সেসের সময় প্রয়োগ করা হয় যা ব্যবহার করে এবং তারপরে সদস্যতা পরীক্ষা করে ।

আমি অন্য সাতটি পদ্ধতি নিয়ে আলোচনা করব না কারণ এগুলি সবই কম দক্ষ।

ও (এন) জটিলতার সাথে উপরের তালিকাভুক্ত ১১ টির বাইরে আরও অনেকগুলি পদ্ধতি রয়েছে তবে আমি তাদের তালিকা না দেওয়ার সিদ্ধান্ত নিয়েছি কারণ তারা প্রথম ম্যাচে ব্রেক করার চেয়ে পুরো অ্যারে স্ক্যান করে।

এগুলি ব্যবহার করবেন না:

# bad examples
array.grep(element).any? 
array.select { |each| each == element }.size > 0
...

Comments

কতটা সাহসের সাথে বলতে হবে যে রুবির কিছু করার 11 টি উপায় আছে! আপনি যত তাড়াতাড়ি বলবেন যে কেউ আপনাকে দেখিয়ে দিবে যে আপনি # 12, তার পরে # 13 এবং আরও কিছু মিস করেছেন। আমার বক্তব্য রাখার জন্য আমি অন্যান্য উপায়গুলির পরামর্শ দেব, তবে প্রথমে আমাকে 11আপনি কীভাবে গণনা করেছেন সে সম্পর্কে প্রশ্ন করুন । প্রথমত, আপনি খুব কমই পৃথক পদ্ধতি হিসাবে indexএবং find_index(বা findএবং detect) পৃথক পদ্ধতি হিসাবে গণনা করতে পারেন , কারণ এগুলি একই পদ্ধতির কেবল আলাদা নাম। দ্বিতীয়ত, সমস্ত অভিব্যক্তি যা শেষ হয় > 0তা ভুল, যা আমি নিশ্চিত যে একটি তদারকি ছিল। (

— অবিরত

... arr.index(e), উদাহরণস্বরূপ, 0যদি ফেরত দেয় arr[0] == e। উপস্থিত না থাকলে আপনি arr.index(e)রিটার্নগুলি প্রত্যাহার করবেন । তবে কেউ যদি অনুসন্ধান করে থাকে তবে এটি ব্যবহার করা যাবে না । (একই সমস্যা , যা তালিকাভুক্ত নয়)) অ্যারেটিকে একটি সেটে রূপান্তর করা এবং তারপরে সেট পদ্ধতিগুলিকে নিয়োগ করা কিছুটা প্রসারিত is তারপরে কেন হ্যাশে রূপান্তর করবেন না (অ্যারে এবং স্বেচ্ছাচারিত মানগুলির সাথে কী), তারপরে হ্যাশ পদ্ধতি ব্যবহার করবেন? এমনকি যদি কোনও সেটে রূপান্তর করা ঠিক থাকে তবে অন্যান্য সেট পদ্ধতিও ব্যবহার করা যেতে পারে যেমন । ( nileindexnilarrrindex!arr.to_set.add?(e)

— অবিরত

... প্রতিশ্রুত এখানে আরো কয়েকটি পদ্ধতি ব্যবহার করা যেতে পারে আছে: arr.count(e) > 0, arr != arr.dup.delete(e) , arr != arr - [e]এবং arr & [e] == [e]। একজনও নিয়োগ করতে পারে selectএবং reject।

— কেরি সোভেল্যান্ড

আমি মানদণ্ডটি হ'ল কোনও নকলের অনুমতি নেই এবং তালিকায় একটি নির্দিষ্ট উপাদান বিদ্যমান কিনা তা জেনে আমি একটি সেট ব্যবহার করার পরামর্শ দেব । সেটটি খুব দ্রুত এসওওও হয়। অনুসন্ধানের প্রয়োজন হলে অ্যারেগুলি সত্যই ব্যবহার করা উচিত নয়; এগুলি আরও ভালভাবে একটি সারি হিসাবে ব্যবহৃত হয়েছে যেখানে জিনিসগুলি সাময়িকভাবে প্রক্রিয়াজাত করার জন্য সংরক্ষণ করা হয়। কিছু আছে কিনা তা দেখার জন্য হ্যাশ এবং সেট আরও ভাল।

— টিন ম্যান

Answer 7

বেশ কয়েকটি উত্তর প্রস্তাব দেয় Array#include?, তবে একটি গুরুত্বপূর্ণ সতর্কতা রয়েছে: উত্সের দিকে তাকানো এমনকি Array#include?লুপিংও সম্পাদন করে:

rb_ary_includes(VALUE ary, VALUE item)
{
    long i;

    for (i=0; i<RARRAY_LEN(ary); i++) {
        if (rb_equal(RARRAY_AREF(ary, i), item)) {
            return Qtrue;
        }
    }
    return Qfalse;
}

লুপিং ছাড়াই শব্দের উপস্থিতি পরীক্ষা করার উপায়টি আপনার অ্যারের জন্য একটি ট্রাই তৈরি করে। এখানে অনেকগুলি ট্রাই বাস্তবায়ন রয়েছে (গুগল "রুবি ট্রাই")। আমি rambling-trieএই উদাহরণে ব্যবহার করব :

a = %w/cat dog bird/

require 'rambling-trie' # if necessary, gem install rambling-trie
trie = Rambling::Trie.create { |trie| a.each do |e| trie << e end }

এবং এখন আমরা আপনার অ্যারেতে বিভিন্ন শব্দের উপস্থিতি এটির উপরের লুপ না করে পরীক্ষা করতে প্রস্তুত, O(log n)সময়মতো, একই রকম সিনট্যাকটিক সরলতার সাথে Array#include?, সাবলাইনার ব্যবহার করে Trie#include?:

trie.include? 'bird' #=> true
trie.include? 'duck' #=> false

Comments

a.each do ... endউম্ম ... নিশ্চিত না কীভাবে এটি লুপ নয়

— ডোরকনব

মনে রাখবেন যে এটিতে আসলে একটি লুপ অন্তর্ভুক্ত রয়েছে; ও (1) নয় এমন যে কোনও কিছুতে কিছু ধরণের লুপ অন্তর্ভুক্ত রয়েছে। এটি কেবল ইনপুট স্ট্রিংয়ের অক্ষরগুলির চেয়ে লুপ হতে পারে। Set#include?দক্ষতার বিষয়ে উদ্বিগ্ন ব্যক্তিদের জন্য ইতিমধ্যে উল্লিখিত একটি উত্তরের চেয়ে নোট করুন ; স্ট্রিংয়ের পরিবর্তে প্রতীক ব্যবহারের সাথে মিলিয়ে এটি ও (1) গড় ক্ষেত্রে হতে পারে (যদি আপনি স্ট্রিং ব্যবহার করেন তবে হ্যাশকে কেবল গণনা করা হয় ও (এন) যেখানে এন স্ট্রিংয়ের দৈর্ঘ্য)। অথবা আপনি যদি তৃতীয় পক্ষের লাইব্রেরি ব্যবহার করতে চান তবে আপনি একটি নিখুঁত হ্যাশ ব্যবহার করতে পারেন যা হে (1) সবচেয়ে খারাপ ক্ষেত্রে।

— ব্রায়ান ক্যাম্পবেল

আফাইক, Setএর সদস্যদের সূচী করতে হ্যাশ ব্যবহার করে, সুতরাং হ্যাশিংয়ের জন্য সু-বিতরণকৃত (আরও নির্দিষ্টভাবে ও (ইনপুট-আকার) এবং ও (লগ (এন / বালতি-সংখ্যা)) এর জন্য আসলে জটিলতা ও (1) Set#include? হওয়া উচিতSet সন্ধান)

— উরি আগাসি

ত্রি তৈরি ও রক্ষণাবেক্ষণের ব্যয় ঠিক ততটাই। আপনি যদি অ্যারেতে অনেকগুলি অনুসন্ধান অপারেশন করছেন, তবে একটি ট্রিকে জনপ্রিয় করে তুলতে এবং এটি বজায় রাখার জন্য মেমরি এবং সময় ব্যয়টি মূল্যবান তবে একক, এমনকি কয়েকশো বা কয়েক হাজার চেকের জন্য ও (এন) পুরোপুরি উপযুক্ত। আর একটি বিকল্প যার জন্য নির্ভরতা যুক্ত করার দরকার নেই সেগুলি হ'ল অ্যারে বাছাই করা বা এটি সাজানো ক্রমে বজায় রাখা, এই ক্ষেত্রে বাইনারি অনুসন্ধান ও (এলজি এন) অপারেশন অন্তর্ভুক্তি পরীক্ষা করতে ব্যবহার করা যেতে পারে।

— speakingcode

@ স্পেকিংকোড, আপনি সম্ভবত ব্যবহারিক দৃষ্টিকোণ থেকে সঠিক হতে পারেন। তবে ওপি "মানটি বিদ্যমান কিনা তা পরীক্ষা করতে বলে, লুপিং ছাড়া আর কিছুই নয়"। যখন আমি এই উত্তরটি লিখেছিলাম, এখানে অনেকগুলি বাস্তববাদী সমাধান ছিল, তবে এমন কোনওটিই যা প্রকৃতপক্ষে প্রশ্নকারীর আক্ষরিক প্রয়োজনটিকে পূরণ করতে পারে না। আপনার পর্যবেক্ষণ যে বিএসটিগুলি চেষ্টাগুলির সাথে সম্পর্কিত তা সঠিক, তবে স্ট্রিংগুলির জন্য, ট্রাই হ'ল কাজের জন্য সঠিক সরঞ্জাম, এমনকি উইকিপিডিয়া এটিও অনেক কিছু জানেন । একটি সু-বাস্তবায়িত ট্রাই নির্মাণ ও রক্ষণাবেক্ষণের জটিলতা আশ্চর্যজনকভাবে অনুকূল।

— বরিস স্ট্যাটনিিকি

Answer 8

যদি আপনি লুপ করতে না চান তবে অ্যারে দিয়ে এটি করার কোনও উপায় নেই। পরিবর্তে আপনার একটি সেট ব্যবহার করা উচিত।

require 'set'
s = Set.new
100.times{|i| s << "foo#{i}"}
s.include?("foo99")
 => true
[1,2,3,4,5,6,7,8].to_set.include?(4) 
  => true

অভ্যন্তরীণভাবে হ্যাশগুলির মতো কাজ করে সেট করুন, সুতরাং রুবিকে আইটেমগুলি সন্ধানের জন্য সংগ্রহের মধ্য দিয়ে লুপ করার দরকার নেই, যেহেতু নামটি থেকেই বোঝা যাচ্ছে এটি কীগুলির হ্যাশগুলি তৈরি করে এবং একটি মেমরি মানচিত্র তৈরি করে যাতে প্রতিটি হ্যাশ স্মৃতিতে একটি নির্দিষ্ট বিন্দুতে নির্দেশ করে। পূর্ববর্তী উদাহরণটি একটি হ্যাশ দিয়ে করা হয়েছিল:

fake_array = {}
100.times{|i| fake_array["foo#{i}"] = 1}
fake_array.has_key?("foo99")
  => true

নেতিবাচক দিকটি হ'ল সেটস এবং হ্যাশ কীগুলি কেবল অনন্য আইটেমগুলিকে অন্তর্ভুক্ত করতে পারে এবং আপনি যদি প্রচুর আইটেম যুক্ত করেন তবে রুবি একটি নতুন মানচিত্র তৈরি করতে নির্দিষ্ট সংখ্যক আইটেমের পরে পুরো জিনিসটি পুনঃস্থাপন করতে হবে যা একটি বৃহত্তর কীস্পেসের জন্য উপযুক্ত। এই সম্পর্কে আরও তথ্যের জন্য, আমি আপনাকে " মাউন্টেন ওয়েস্ট রুবিকনফ ২০১৪ - নাথন লং দ্বারা গৃহপালিত হ্যাশ-এ বিগ হে " দেখার পরামর্শ দিচ্ছি ।

এখানে একটি মানদণ্ড রয়েছে:

require 'benchmark'
require 'set'

array = []
set   = Set.new

10_000.times do |i|
  array << "foo#{i}"
  set   << "foo#{i}"
end

Benchmark.bm do |x|
  x.report("array") { 10_000.times { array.include?("foo9999") } }
  x.report("set  ") { 10_000.times { set.include?("foo9999")   } }
end

এবং ফলাফল:

      user     system      total        real
array  7.020000   0.000000   7.020000 (  7.031525)
set    0.010000   0.000000   0.010000 (  0.004816)

Comments

আপনি যদি সনাক্তকরণ ব্যবহার করেন, তবে আপনি কমপক্ষে লুপিং হ্রাস করতে পারেন। সনাক্তকরণ প্রথম আইটেমটি 'সনাক্ত করা' এ থামবে (আইটেমটির জন্য ব্লকটি সত্যের কাছে মূল্যায়ন করে)। এছাড়াও, কিছুই সনাক্ত না হলে কী করতে হবে তা সনাক্ত করতে পারেন (আপনি একটি ল্যাম্বডায় পাস করতে পারেন)।

— aenw

@ include?প্রথম হিট থামছে না ?

— কিম্মো লেহ্টো

তুমি একেবারেই সঠিক. আমি সনাক্ত করতে ব্যবহার করতে এতটাই অভ্যস্ত যে আমি এটিকে অন্তর্ভুক্ত করতে ভুলে গিয়েছি। আপনার মন্তব্যের জন্য ধন্যবাদ - এটি নিশ্চিত করেছে যে আমি আমার জ্ঞানকে সতেজ করেছি।

— নতুন

include?প্রথম হিট এ থামে তবে যদি সেই হিট তালিকার শেষের দিকে থাকে .... স্টোরেজটির জন্য অ্যারির উপর নির্ভর করে যে কোনও সমাধানের তালিকা বাড়ার সাথে সাথে হ্রাসজনক পারফরম্যান্স থাকবে, বিশেষত যখন শেষের দিকে কোনও উপাদান সন্ধান করতে হবে তালিকা। হ্যাশ এবং সেটে কোনও সমস্যা নেই, না কোনও অর্ডার করা তালিকা এবং বাইনারি-অনুসন্ধানও হবে।

— টিন ম্যান

এই উত্তরটি প্রথম স্থানে যা ছিল তা হ'ল :)

— কিম্মো লেহ্টো

Answer 9

এটি করার আরেকটি উপায়: Array#indexপদ্ধতিটি ব্যবহার করুন ।

এটি অ্যারেতে উপাদানের প্রথম উপস্থিতির সূচকটি প্রদান করে।

উদাহরণ স্বরূপ:

a = ['cat','dog','horse']
if a.index('dog')
    puts "dog exists in the array"
end

index() এছাড়াও একটি ব্লক নিতে পারেন:

উদাহরণ স্বরূপ:

a = ['cat','dog','horse']
puts a.index {|x| x.match /o/}

এটি অ্যারে প্রথম শব্দের সূচীটি দেয় যা অক্ষরে 'o' থাকে।

Comments

indexএখনও অ্যারের উপর পুনরাবৃত্তি, এটি কেবল উপাদানটির মান প্রদান করে।

— টিন ম্যান

Answer 10

মজার ব্যাপার,

আপনি *একটি caseঅভিব্যক্তিগুলিতে অ্যারের সদস্যতা চেক করতে ব্যবহার করতে পারেন ।

case element
when *array 
  ...
else
  ...
end

একটু খেয়াল করুন *যখন ক্লজটিতে , অ্যারেতে সদস্যতার জন্য এটি পরীক্ষা করে।

স্প্ল্যাট অপারেটরের সমস্ত সাধারণ যাদু আচরণ প্রযোজ্য, সুতরাং উদাহরণস্বরূপ যদি arrayআসলে কোনও অ্যারে না হয় তবে একটি একক উপাদান এটি সেই উপাদানটির সাথে মেলে।

Comments

জানা ভাল..!

— কেরি সোভেলল্যান্ড

এটি কেস স্টেটমেন্টের ধীরে ধীরে প্রথম চেকও হবে, তাই আমি এটি সর্বশেষ whenসম্ভব ব্যবহার করতাম যাতে অন্যান্য, দ্রুত চেকগুলি দ্রুত নিড়ান।

— টিন ম্যান

Answer 11

এটি সম্পাদন করার একাধিক উপায় রয়েছে। তাদের কয়েকটি নিম্নরূপ:

a = [1,2,3,4,5]

2.in? a  #=> true

8.in? a #=> false

a.member? 1 #=> true

a.member? 8 #=> false

Comments

নোট যা Object#in?কেবলমাত্র কারাগারে যুক্ত হয়েছিল (যেমন ActiveSupport) v3.1 +। এটি কোর রুবিতে পাওয়া যায় না।

— টম লর্ড

Answer 12

আপনার যদি কোনও কীটির জন্য বহুগুণ পরীক্ষা arrকরতে হয় তবে রূপান্তর করুন hashএবং এখন ও (1) এ চেক করুন

arr = ['Cat', 'Dog', 'Bird']
hash = arr.map {|x| [x,true]}.to_h
 => {"Cat"=>true, "Dog"=>true, "Bird"=>true}
hash["Dog"]
 => true
hash["Insect"]
 => false

হ্যাশ এর পারফরম্যান্স # হাসি_কি? বনাম অ্যারে # অন্তর্ভুক্ত?

প্যারামিটার হ্যাশ # has_key? এরে # অন্তর্ভুক্ত

সময় জটিলতা (1) অপারেশন ও (এন) অপারেশন 

অ্যাক্সেস প্রকার অ্যাক্সেস করে হ্যাশ [কী] যদি এটি প্রতিটি উপাদানগুলির মধ্যে মেলে
                        যতক্ষণ না অ্যারে এর পরে কোনও মান প্রদান করে
                        সত্য অ্যারে মান খুঁজে ফিরে আসে
                        হ্যাশ # has_key? কল
                        কল    

একক সময়ের জন্য চেক ব্যবহার include?করা ভাল

Comments

আপনি কি এখনও এটিকে হ্যাশে রূপান্তর করতে অ্যারের মাধ্যমে লুপিং করছেন না?

— chrisjacob

হ্যাঁ, আমি করেছি কিন্তু এখন অ্যারের সাথে কোনও উপাদান রয়েছে কি না তা যাচাই করার জন্য আমার কাছে প্রাক-গণিত উত্তর রয়েছে। এখন, পরের বার যখন আমি অন্য শব্দের অনুসন্ধান করব তখন এটি প্রশ্নের জন্য ও (1) নিবে ঠিক যদিও প্রাক-গণনাটি ও (এন) নেবে। আসলে আমি অন্তর্ভুক্ত ব্যবহার করেছি? অ্যারেতে নির্দিষ্ট উপাদান রয়েছে কি না তা যাচাই করার জন্য আমার আবেদনের লুপের ভিতরে, এটি কর্মক্ষমতা নষ্ট করে দেয়, এটি রুবি-প্রো-তে চেক করেছিল, এটি ছিল বাধা

— আকফারিদি

.... তবে হে (এন) স্পেস এবং এটিও ও (এন) সময় নয়, কারণ @ ক্রিসিয়াস 72205 যথাযথভাবে উল্লেখ করেছে, আপনাকে প্রথমে আপনার অ্যারের মাধ্যমে পুনরাবৃত্তি করতে হবে। ও (1) + ও (এন) = ও (এন)। সুতরাং আসলে, এই উপায় অন্তর্ভুক্ত চেয়ে খারাপ?

— রামবাতিনো

ডুড আমি কেবল বলছিলাম না ব্যবহারের লুপের মধ্যে অন্তর্ভুক্ত না, একক সময় ব্যবহারের জন্য অন্তর্ভুক্ত ব্যবহার চেক ভাল। সুতরাং দয়া করে প্রথমে ব্যবহারের কেসটি পড়ুন, লুপের ভিতরে যদি আপনার একাধিকবার পরীক্ষা করা প্রয়োজন হয় তবে এটি আরও ভাল।

— আকফারিদি

একটি অ্যারে হ্যাশে রূপান্তর করা ব্যয়বহুল, তবে অনুসন্ধানের জন্য অ্যারে ব্যবহার করা ভুল কাঠামো। অ্যারেগুলি সারি হিসাবে আরও ভাল যেখানে ক্রমটি গুরুত্বপূর্ণ হতে পারে; অন্তর্ভুক্তি / অস্তিত্ব / স্বতন্ত্রতা গুরুত্বপূর্ণ হলে হ্যাশ এবং সেটগুলি আরও ভাল। ডান পাত্রে শুরু করুন এবং সমস্যাটি হ'ল।

— টিন ম্যান

Answer 13

এটি আপনাকে কেবল এটিই বলে দেবে যে এটি বিদ্যমান but

 a = ['Cat', 'Dog', 'Bird']
 a.count("Dog")
 #=> 1

Comments

এটি কতবার প্রদর্শিত হয় তা আপনি জানতে না চাইলে এটি ব্যবহার করার কোনও ধারণা নেই, যদিও .any?এটি প্রথম মিলার উপাদানটি খুঁজে পাওয়ার সাথে সাথে ফিরে .countআসবে, সর্বদা পুরো অ্যারেটি প্রক্রিয়া করবে।

— জাজ

যদিও এই প্রযুক্তিগতভাবে কিছু উপস্থিত রয়েছে কিনা তা বলবে, আপনি গতির যত্ন নিলে এটি করার সঠিক উপায়ও নয় ।

— টিন ম্যান

Answer 14

এটি মূল্যবান কিসের জন্য, রুবি ডকস এই ধরণের প্রশ্নের এক আশ্চর্যজনক উত্স।

আপনি যে অ্যারের মাধ্যমে সন্ধান করছেন সেটিও আমি নোট করব take include?পদ্ধতি হে (ঢ) জটিলতা একটি রৈখিক অনুসন্ধান যা অ্যারের আকারের উপর নির্ভর করে প্রশংসনীয় কুশ্রী পেতে পারেন চালানো হবে।

যদি আপনি একটি বৃহত (সাজানো) অ্যারে নিয়ে কাজ করছেন তবে আমি একটি বাইনারি অনুসন্ধান অ্যালগরিদম লেখার বিষয়টি বিবেচনা করব যা খুব বেশি কঠিন হবে না এবং ও (লগ এন) এর সবচেয়ে খারাপ পরিস্থিতি রয়েছে।

বা আপনি যদি রুবি ২.০ ব্যবহার করছেন তবে আপনি সুবিধা নিতে পারেন bsearch।

Comments

একটি বাইনারি অনুসন্ধান ধরে নেওয়া হয় যে অ্যারেটি সাজানো হয়েছে (বা কোনও আকারে অর্ডার করা হয়েছে) যা বড় অ্যারেগুলির জন্য ব্যয়বহুল হতে পারে, প্রায়শই সুবিধা উপেক্ষা করে।

— টিন ম্যান

বাইনারি অনুসন্ধানে সমস্ত জোড়া উপাদানগুলির সাথে তুলনামূলক হওয়া প্রয়োজন <=>, যা সর্বদা ক্ষেত্রে হয় না। ধরুন, উদাহরণস্বরূপ, অ্যারের উপাদানগুলি হ্যাশ ছিল।

— কেরি সোভেল্যান্ড

@ ক্যারি সোয়েভল্যান্ডকে কম-বেশি বোঝানো উচিত যে বাছাই করা অ্যারের মধ্যে থাকা উপাদানগুলি তুলনীয়।

— dvissp14

Answer 15

আপনি চেষ্টা করতে পারেন:

উদাহরণ: ক্যাট এবং কুকুর অ্যারে উপস্থিত থাকলে:

(['Cat','Dog','Bird'] & ['Cat','Dog'] ).size == 2   #or replace 2 with ['Cat','Dog].size

পরিবর্তে:

['Cat','Dog','Bird'].member?('Cat') and ['Cat','Dog','Bird'].include?('Dog')

দ্রষ্টব্য: member?এবং include?একই।

এটি এক লাইনে কাজ করতে পারে!

Answer 16

আমরা যদি ব্যবহার করতে না চাই include? এটিও কাজ করে:

['cat','dog','horse'].select{ |x| x == 'dog' }.any?

Comments

কোন? এছাড়াও ব্লকগুলি গ্রহণ করে: ['বিড়াল', 'কুকুর', 'ঘোড়া']। কোনও? {| এক্স | x == 'কুকুর'}

— মাইকোনাস

Answer 17

['Cat', 'Dog', 'Bird'].detect { |x| x == 'Dog'}
=> "Dog"
!['Cat', 'Dog', 'Bird'].detect { |x| x == 'Dog'}.nil?
=> true

Comments

['Cat', nil, 'Dog'].detect { |x| x == nil } #=> nil। ছিল nilপাওয়া গেছে?

— ক্যারি সোভেল্যান্ড

Answer 18

কিভাবে এই উপায়?

['Cat', 'Dog', 'Bird'].index('Dog')

Comments

এটি এখনও উপাদান খুঁজে পেতে অ্যারের উপর পুনরাবৃত্তি হতে চলেছে। তারপরে এটি সেই উপাদানটির সূচকটি ফেরত দিতে হবে।

— টিন ম্যান

Answer 19

আপনি যদি মিনি টেস্ট ইউনিট পরীক্ষায় এটি করার চেষ্টা করছেন তবে আপনি এটি ব্যবহার করতে পারেন assert_includes। উদাহরণ:

pets = ['Cat', 'Dog', 'Bird']
assert_includes(pets, 'Dog')      # -> passes
assert_includes(pets, 'Zebra')    # -> fails 

Answer 20

এই কাছাকাছি অন্য উপায় আছে।

ধরুন অ্যারে [ :edit, :update, :create, :show ], ভাল সম্ভবত সমগ্র সাত মারাত্মক / বিশ্রামরত পাপের ।

এবং কিছু খেলনা থেকে একটি বৈধ পদক্ষেপ টান ধারণা সঙ্গে আরও খেলনা :

"my brother would like me to update his profile"

তারপর:

[ :edit, :update, :create, :show ].select{|v| v if "my brother would like me to update his profile".downcase =~ /[,|.| |]#{v.to_s}[,|.| |]/}

Comments

আপনার রেজেক্স, /[,|.| |]#{v.to_s}[,|.| |]/আমাকে ভাবিয়ে তোলে যে আপনি 'কমা, সময়কাল, স্থান বা কিছুই নয়' এর মধ্যে ঘিরে থাকা ক্রিয়াটির নামটি খুঁজে পেতে চেয়েছিলেন তবে কিছু সূক্ষ্ম বাগ রয়েছে। "|update|"ফিরে আসবে [:update]এবং "update"ফিরে আসবে []। অক্ষর শ্রেণীর ( [...]) |অক্ষরগুলি পৃথক করতে পাইপ ( ) ব্যবহার করবেন না । এমনকি যদি আমরা এগুলিকে গোষ্ঠীতে ( (...)) পরিবর্তন করি তবে আপনি খালি চরিত্রের সাথে মেলে না। সুতরাং আপনি সম্ভবত যে /(,|\.| |^)#{v.to_s}(,|\.| |$)/

— রেজেক্সটি

রেজেক্স ঠিক আছে (চেক রুবারার ডট কম) - এবং @ রাম্বাটিনো: উদাহরণস্বরূপ কেন অ্যামাজন ইকোর মতো হবে;) আপনি বলতে পারেন: "দয়া করে আমার শপিং তালিকায় মুরগি যুক্ত করুন" (এবং - ভাল - তবে আপনাকে করতে হবে যোগ করুন: অ্যারেতে যোগ করুন, তবে আমি মনে করি আপনি এটির

— সংক্ষেপটি পেয়েছেন

"রেজেক্স ঠিক আছে (চেক করা রুবারার.কম)"। এটা ঠিক নেই। আপনার রেজেক্স কোনও স্ট্রিংয়ের শুরু বা শেষে কোনও কীওয়ার্ডের সাথে মেলে না (যেমন "আমার ভাইয়ের প্রোফাইল আপডেট করুন") " আপনি যদি শুরু বা শেষের সাথে মিল রাখতে চান না, তবে আপনার রেজেক্স এখনও ঠিক নেই কারণ /[,. ]/

— মূলশব্দটির

যেমনটি @bkDJ বলেছেন, রেজেেক্স ভুল। rubular.com/r/4EG04rANz6KET6

— টিন ম্যান

Answer 21

আপনি যদি মানটি সত্য বা মিথ্যা না করে ফিরিয়ে দিতে চান তবে ব্যবহার করুন

array.find{|x| x == 'Dog'}

তালিকায় উপস্থিত থাকলে এটি 'কুকুর' ফিরিয়ে দেবে, অন্যথায় শূন্য হবে না।

Comments

বা ব্যবহার array.any?{|x| x == 'Dog'}যদি আপনি না সত্য / মিথ্যা (না মান) চান, কিন্তু এই মত একটি ব্লক বিরুদ্ধে তুলনা করতে চাই।

— মাহেমফ

Answer 22

এটি করার আরও একটি উপায় এখানে:

arr = ['Cat', 'Dog', 'Bird']
e = 'Dog'

present = arr.size != (arr - [e]).size

Comments

এটি করার জন্য এটি অত্যন্ত ভয়ঙ্করভাবে অকার্যকর উপায়! আমি ডাউনভোটিং করছি না কারণ এটি প্রযুক্তিগতভাবে ভুল নয়, এবং কেউ এটি পড়তে থেকে রুবি সম্পর্কে কিছু শিখতে পারে তবে উপরে আরও অনেক ভাল উত্তর রয়েছে।

— jibberia

শঙ্কু, আপনি সহজ করতে পারেন arr != arr - [e]। arr & [e] == [e]একই লাইন বরাবর অন্য উপায়।

— কেরি সোভেল্যান্ড

@ ক্যারি সোয়েভল্যান্ড কোনও উইজার্ডের টুপি নিয়ে মজা করবেন না ;-)

— ওয়ান্ডার মেকার

আমি উইজার্ডের মাথাটি উল্লেখ করছিলাম, টুপি নয়, সবচেয়ে শ্রদ্ধার সাথে।

— কেরি সোভোল্যান্ড

Answer 23

array = [ 'Cat', 'Dog', 'Bird' ]
array.include?("Dog")

Answer 24

এটিতে কোনও অ্যারেতে উপাদান খুঁজে বের করার অনেক উপায় রয়েছে তবে সহজ উপায়টি 'ইন'? পদ্ধতি।

example:
arr = [1,2,3,4]
number = 1
puts "yes #{number} is present in arr" if number.in? arr

Comments

নোট: বর্ণনা অনুযায়ী এই উত্তর , পদ্ধতি in?প্রয়োজন ActiveSupportআমদানি করতে: require active_support।

— প্যাট্রিক

যদি আপনি মূল এক্সটেনশনগুলি ব্যবহার করেন তবে এটির জন্য সমস্ত অ্যাক্টিভাসপোর্টের প্রয়োজন হয় না ।

— টিন ম্যান

Answer 25

আপনি যদি ব্যবহার include?করতে না চান তবে আপনি প্রথমে উপাদানটিকে একটি অ্যারেতে আবদ্ধ করতে পারেন এবং তারপরে মোড়ানো উপাদানটি অ্যারে এবং মোড়ানো উপাদানটির ছেদ করার সমান কিনা তা পরীক্ষা করতে পারেন। এটি সমতার ভিত্তিতে একটি বুলিয়ান মান প্রদান করবে।

def in_array?(array, item)
    item = [item] unless item.is_a?(Array)
    item == array & item
end

Answer 26

আমি কিছু কিছু করার বিভিন্ন উপায়ের আপেক্ষিক গতি দেখতে কিছু বেঞ্চমার্ক চালানো আকর্ষণীয় মনে করি।

শুরুতে, মাঝারি বা শেষ দিকে একটি অ্যারের উপাদান সন্ধান করা যেকোন রৈখিক অনুসন্ধানগুলিকে প্রভাবিত করবে কিন্তু একটি সেট বিরুদ্ধে সবেমাত্র সন্ধানকে প্রভাবিত করবে।

একটি অ্যারেকে একটি সেটে রূপান্তরকরণ প্রক্রিয়াজাতকরণের সময়কে হিট করতে চলেছে, তাই একবার অ্যারে থেকে সেট তৈরি করুন, বা শুরু থেকেই সেট দিয়ে শুরু করুন।

মানদণ্ডের কোডটি এখানে:

# frozen_string_literal: true

require 'fruity'
require 'set'

ARRAY = (1..20_000).to_a
SET = ARRAY.to_set

DIVIDER = '-' * 20

def array_include?(elem)
  ARRAY.include?(elem)
end

def array_member?(elem)
  ARRAY.member?(elem)
end

def array_index(elem)
  ARRAY.index(elem) >= 0
end

def array_find_index(elem)
  ARRAY.find_index(elem) >= 0
end

def array_index_each(elem)
  ARRAY.index { |each| each == elem } >= 0
end

def array_find_index_each(elem)
  ARRAY.find_index { |each| each == elem } >= 0
end

def array_any_each(elem)
  ARRAY.any? { |each| each == elem }
end

def array_find_each(elem)
  ARRAY.find { |each| each == elem } != nil
end

def array_detect_each(elem)
  ARRAY.detect { |each| each == elem } != nil
end

def set_include?(elem)
  SET.include?(elem)
end

def set_member?(elem)
  SET.member?(elem)
end

puts format('Ruby v.%s', RUBY_VERSION)

{
  'First' => ARRAY.first,
  'Middle' => (ARRAY.size / 2).to_i,
  'Last' => ARRAY.last
}.each do |k, element|
  puts DIVIDER, k, DIVIDER

  compare do
    _array_include?        { array_include?(element)        }
    _array_member?         { array_member?(element)         }
    _array_index           { array_index(element)           }
    _array_find_index      { array_find_index(element)      }
    _array_index_each      { array_index_each(element)      }
    _array_find_index_each { array_find_index_each(element) }
    _array_any_each        { array_any_each(element)        }
    _array_find_each       { array_find_each(element)       }
    _array_detect_each     { array_detect_each(element)     }
  end
end

puts '', DIVIDER, 'Sets vs. Array.include?', DIVIDER
{
  'First' => ARRAY.first,
  'Middle' => (ARRAY.size / 2).to_i,
  'Last' => ARRAY.last
}.each do |k, element|
  puts DIVIDER, k, DIVIDER

  compare do
    _array_include? { array_include?(element) }
    _set_include?   { set_include?(element)   }
    _set_member?    { set_member?(element)    }
  end
end

কোনটি যখন আমার ম্যাক ওএস ল্যাপটপে চালিত হয় তখন ফলাফল:

Ruby v.2.7.0
--------------------
First
--------------------
Running each test 65536 times. Test will take about 5 seconds.
_array_include? is similar to _array_index
_array_index is similar to _array_find_index
_array_find_index is faster than _array_any_each by 2x ± 1.0
_array_any_each is similar to _array_index_each
_array_index_each is similar to _array_find_index_each
_array_find_index_each is faster than _array_member? by 4x ± 1.0
_array_member? is faster than _array_detect_each by 2x ± 1.0
_array_detect_each is similar to _array_find_each
--------------------
Middle
--------------------
Running each test 32 times. Test will take about 2 seconds.
_array_include? is similar to _array_find_index
_array_find_index is similar to _array_index
_array_index is faster than _array_member? by 2x ± 0.1
_array_member? is faster than _array_index_each by 2x ± 0.1
_array_index_each is similar to _array_find_index_each
_array_find_index_each is similar to _array_any_each
_array_any_each is faster than _array_detect_each by 30.000000000000004% ± 10.0%
_array_detect_each is similar to _array_find_each
--------------------
Last
--------------------
Running each test 16 times. Test will take about 2 seconds.
_array_include? is faster than _array_find_index by 10.000000000000009% ± 10.0%
_array_find_index is similar to _array_index
_array_index is faster than _array_member? by 3x ± 0.1
_array_member? is faster than _array_find_index_each by 2x ± 0.1
_array_find_index_each is similar to _array_index_each
_array_index_each is similar to _array_any_each
_array_any_each is faster than _array_detect_each by 30.000000000000004% ± 10.0%
_array_detect_each is similar to _array_find_each

--------------------
Sets vs. Array.include?
--------------------
--------------------
First
--------------------
Running each test 65536 times. Test will take about 1 second.
_array_include? is similar to _set_include?
_set_include? is similar to _set_member?
--------------------
Middle
--------------------
Running each test 65536 times. Test will take about 2 minutes.
_set_member? is similar to _set_include?
_set_include? is faster than _array_include? by 1400x ± 1000.0
--------------------
Last
--------------------
Running each test 65536 times. Test will take about 4 minutes.
_set_member? is similar to _set_include?
_set_include? is faster than _array_include? by 3000x ± 1000.0

মূলত ফলাফলগুলি আমাকে সমস্ত কিছুর জন্য একটি সেট ব্যবহার করতে বলে যদি আমি অন্তর্ভুক্তির জন্য অনুসন্ধান করতে যাচ্ছি তবে আমি নিশ্চিত করতে পারি না যে আমি চাই যে প্রথম উপাদানটি আমি চাই, যা খুব সম্ভবত নয়। হ্যাশগুলিতে উপাদানগুলি সন্নিবেশ করানোর সময় কিছু ওভারহেড থাকে তবে অনুসন্ধানের সময়গুলি এত দ্রুত হয় আমি কখনই এটি বিবেচনা করা উচিত বলে মনে করি না। আবার, আপনার যদি এটি অনুসন্ধান করতে হয় তবে কোনও অ্যারে ব্যবহার করবেন না, একটি সেট ব্যবহার করুন। (বা একটি হ্যাশ।)

অ্যারে যত ছোট হবে তত দ্রুত অ্যারে পদ্ধতিগুলি চলবে, তবে তারা এখনও চালিয়ে যাচ্ছে না, যদিও ছোট অ্যারেগুলিতে পার্থক্যটি সামান্য হতে পারে।

"প্রথম", "মধ্য" এবং "সর্বশেষ" ব্যবহার প্রতিফলিত first, size / 2এবং lastজন্য ARRAYজন্য উপাদান হচ্ছে জন্য অনুসন্ধান করেছেন। যে উপাদান সেগুলি অনুসন্ধানের ব্যবহার করা হবে ARRAYএবং SETভেরিয়েবল।

যে পদ্ধতিগুলির সাথে তুলনা করা হচ্ছে তার জন্য ছোটখাটো পরিবর্তন করা হয়েছিল > 0কারণ পরীক্ষাটি টাইপ পরীক্ষার >= 0জন্য হওয়া উচিত index।

ফল এবং তার পদ্ধতি সম্পর্কে আরও তথ্য এর README এ উপলব্ধ ।