රූබිට අරාවෙහි මූලද්‍රව්‍ය සොයා ගැනීමට ක්රම එකොළහක් ඇත.
කැමති එකක් 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?O (n) කාල සංකීර්ණතාවයක් ඇත.
මුලින් අරාවෙහි හැෂ් නිරූපණයක් සෑදීමේ වියදමින් O (1) ප්රවේශ වේලාව ලබා ගැනීමට අපට කට්ටලයක් භාවිතා කළ හැකිය. ඔබ එකම පෙළේ සාමාජිකත්වය නැවත නැවත පරීක්ෂා කරන්නේ නම් මෙම ආරම්භක ආයෝජනය ඉක්මනින් ගෙවිය හැකිය. SetC හි ක්‍රියාත්මක නොවන නමුත් සරල රූබි පන්තියක් ලෙස තවමත් යටින් පවතින O (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නිදසුනක් නිර්මාණය කරන බව ඔබට පෙනෙන පරිදි , සියලු වස්තූන් සිතියම් ගත කර පසුව හැෂ් පන්තියේ O (1) ප්රවේශ වේලාව සමඟ ක්‍රියාත්මක වන trueසාමාජිකත්වය පරීක්ෂා Hash#include?කරයි.
අනෙක් ක්රම 7 ම කාර්යක්ෂම නොවන බැවින් මම සාකච්ඡා නොකරමි.
ඉහත ලැයිස්තුගත කර ඇති 11 න් ඔබ්බට O (n) සංකීර්ණතාවයෙන් තවත් බොහෝ ක්රම තිබේ, නමුත් පළමු තරඟයේ දී බිඳවැටීමට වඩා සමස්ත අරා පරිලෝකනය කරන බැවින් ඒවා ලැයිස්තුගත නොකිරීමට මම තීරණය කළෙමි.
මේවා භාවිතා නොකරන්න:
# bad examples
array.grep(element).any?
array.select { |each| each == element }.size > 0
...