मैं किसी एक तत्व को मान से कैसे हटा सकता हूं

Question

मैं रूबी में तत्वों की एक सरणी है

[2,4,6,3,8]

मुझे 3उदाहरण के लिए मान वाले तत्वों को निकालने की आवश्यकता है

मैं उसको कैसे करू?

Comments

मुझे आश्चर्य है कि delete array.delete(3)रेल नियंत्रक पर माणिक के भीतर काम क्यों नहीं किया जाता है

— इमराननक्वी

active recordविधि के कारण हो सकता हैdelete

— ImranNaqvi

Answer 1

मुझे लगता है कि मैंने इसका पता लगा लिया है:

a = [3, 2, 4, 6, 3, 8]
a.delete(3)
#=> 3
a
#=> [2, 4, 6, 8]

Comments

मैं व्यक्तिगत रूप से की तरह [1, 2, 3, 4, 5] - [3]में परिणाम जो => [1, 2, 4, 5]से irb।

— ट्रैविस

क्या होगा अगर 3 की कई प्रविष्टियाँ हैं और हम उनमें से केवल एक को हटाना चाहते हैं? (यह संबंधित है इसलिए यह पूछना सबसे अच्छा हो सकता है)

— नवनीत

बस एक हेड अप जो .delete () हटाए गए मान को लौटाएगा, हटाए गए मान के साथ संशोधित सरणी नहीं।

— जोशुआ पिंटर

विचार करने के लिए अन्य परिणाम यह है कि हटाए गए मूल्य के बिना एक नया सरणी बनाता है ( deleteजबकि -आपको वापस कर दिया गया है) अंतर्निहित सरणी को बदल देता है । आपके उपयोग के मामले के आधार पर या तो दृष्टिकोण समझ में आ सकता है।

— srt32

@ user3721428, हटाएं (3) स्थिति 3 में तत्व को संदर्भित नहीं करता है, बल्कि पूर्णांक 3 से मेल खाने वाले किसी भी तत्व को हटाता है। यह 3 की सभी घटनाओं को हटा देगा और इसका सरणियों सूचकांक या स्थिति से कोई लेना-देना नहीं है।

— bkunzi01

Answer 2

टिप्पणियों में ट्रैविस से उधार लेना , यह एक बेहतर जवाब है:

मैं व्यक्तिगत रूप से की तरह [1, 2, 7, 4, 5] - [7]है, जिसमें परिणाम => [1, 2, 4, 5]सेirb

मैंने उनके उत्तर को यह देखकर संशोधित किया कि 3 उनके उदाहरण सरणी में तीसरा तत्व था। यह उन लोगों के लिए कुछ भ्रम पैदा कर सकता है जिन्हें यह एहसास नहीं है कि 3 सरणी में स्थिति 2 में है।

Comments

जैसे ही srt32 उत्तर में बताता है, उपयोग करने .deleteऔर बनाने के बीच एक महत्वपूर्ण अंतर है -। .deleteवह मान लौटाएगा जो ऐरे से निकाला गया था, यदि कोई हो; -नहीं होगा। तो [ 1, 2, 3 ] - [ 2 ]लौटेगा [ 1, 3 ], जबकि [ 1, 2, 3 ].delete( 2 )लौटेगा 2।

— अरगस

array - subArrayऐरे के एरे के लिए काम नहीं करेगा , लेकिन array.delete(subArray)करेगा।

— सचिन

के बीच बहुत महत्वपूर्ण अंतर है [1,2,3] - [2]और [1,2,3].delete(2)वह deleteतरीका मूल सरणी को संशोधित करता है , जबकि [1,2,3] - [3]एक नया सरणी बनाता है ।

— टिमोथी कोवालेव

री सबरेज़ (@ सचिन की टिप्पणी ऊपर) "ज़रूर करेंगे", आपको सिर्फ नोटेशन सही पाने की ज़रूरत है: [1,2,[2],2,3,4] - [2]आपको देता है [1, [2], 3, 4], लेकिन [1,2,[2],2,3,4] - [[2]]आपको देता है [1, 2, 2, 3, 4]। :-)

— टॉम हंड्ट

Answer 3

एक अन्य विकल्प:

a = [2,4,6,3,8]

a -= [3]

जिसके परिणामस्वरूप

=> [2, 4, 6, 8] 

Answer 4

मुझे यकीन नहीं है कि किसी ने भी यह कहा है, लेकिन Array.delete () और - = मान ऐरे के भीतर इसके पास दिए गए मूल्य के हर उदाहरण को हटा देगा। विशेष तत्व के पहले उदाहरण को हटाने के लिए आप कुछ ऐसा कर सकते हैं

arr = [1,3,2,44,5]
arr.delete_at(arr.index(44))

#=> [1,3,2,5]

एक सरल तरीका हो सकता है। मैं यह नहीं कह रहा हूं कि यह सबसे अच्छा अभ्यास है, लेकिन यह कुछ ऐसा है जिसे पहचाना जाना चाहिए।

Comments

मैं यह करने के लिए एक रास्ता खोज रहा था और केवल डुप्लिकेट के तत्व के एक उदाहरण को हटाता हूं और यह बहुत अच्छा काम करता है!

— ज़ेरोशोगुन

मुझे लगता है कि यह उत्तर गलत है, बस क्योंकि arr.index () जा सकता हैnil

— windmaomao

Answer 5

मान लें कि आप किसी सरणी में कई स्थानों पर मान द्वारा 3 को हटाना चाहते हैं, मुझे लगता है कि इस कार्य को करने के लिए माणिक तरीका delete_if पद्धति का उपयोग करना होगा:

[2,4,6,3,8,3].delete_if {|x| x == 3 } 

आप 'सरणी के सरणी' के परिदृश्य में तत्वों को हटाने में भी delete_if का उपयोग कर सकते हैं।

आशा है कि यह आपकी क्वेरी को हल करता है

Answer 6

मैं -=[4]उन तत्वों को हटाने के लिए अन्य उत्तर में वर्णित तरीका पसंद करता हूं जिनके मूल्य 4 हैं।

लेकिन इस तरह से है:

irb(main):419:0> [2,4,6,3,8,6].delete_if{|i|i==6}
=> [2, 4, 3, 8]
irb(main):420:0>

" बेसिक एरे ऑपरेशंस " में कहीं उल्लेख किया गया है , क्योंकि यह mapफ़ंक्शन का उल्लेख करता है।

Comments

लेकिन तुम सिर्फ उपयोग नहीं कर सकते.delete(6)

— Zac

@Zac बेशक, लेकिन उस उत्तर का पहले ही उल्लेख किया जा चुका है (जैसा कि बहुत संक्षिप्त -=तरीका है । a-=[4]यानी , जो मैंने कहा कि मुझे पसंद है), लेकिन मैं एक और संभावित तरीके का उल्लेख करना चाहता था। a=a-[4][3,4]-[4]

— बार्लोप

इस विधि में हटाए गए तत्व के बजाय सरणी को वापस करने का भी लाभ है।

— F.Webber

Answer 7

आप बस चला सकते हैं:

[2,4,6,3,8].delete(3)

Answer 8

.delete_at(3) 3यहाँ एक स्थिति है।

Answer 9

यहाँ कुछ बेंचमार्क हैं:

require 'fruity'


class Array          
  def rodrigo_except(*values)
    self - values
  end    

  def niels_except value
    value = value.kind_of?(Array) ? value : [value]
    self - value
  end
end

ARY = [2,4,6,3,8]

compare do
  soziev  { a = ARY.dup; a.delete(3);               a }
  steve   { a = ARY.dup; a -= [3];                  a }
  barlop  { a = ARY.dup; a.delete_if{ |i| i == 3 }; a }
  rodrigo { a = ARY.dup; a.rodrigo_except(3);         }
  niels   { a = ARY.dup; a.niels_except(3);           }
end

# >> Running each test 4096 times. Test will take about 2 seconds.
# >> soziev is similar to barlop
# >> barlop is faster than steve by 2x ± 1.0
# >> steve is faster than rodrigo by 4x ± 1.0
# >> rodrigo is similar to niels

और फिर से एक बड़े सरणी के साथ जिसमें बहुत सारे डुप्लिकेट हैं:

class Array          
  def rodrigo_except(*values)
    self - values
  end    

  def niels_except value
    value = value.kind_of?(Array) ? value : [value]
    self - value
  end
end

ARY = [2,4,6,3,8] * 1000

compare do
  soziev  { a = ARY.dup; a.delete(3);               a }
  steve   { a = ARY.dup; a -= [3];                  a }
  barlop  { a = ARY.dup; a.delete_if{ |i| i == 3 }; a }
  rodrigo { a = ARY.dup; a.rodrigo_except(3);         }
  niels   { a = ARY.dup; a.niels_except(3);           }
end

# >> Running each test 16 times. Test will take about 1 second.
# >> steve is faster than soziev by 30.000000000000004% ± 10.0%
# >> soziev is faster than barlop by 50.0% ± 10.0%
# >> barlop is faster than rodrigo by 3x ± 0.1
# >> rodrigo is similar to niels

और भी अधिक डुप्लिकेट के साथ बड़ा:

class Array          
  def rodrigo_except(*values)
    self - values
  end    

  def niels_except value
    value = value.kind_of?(Array) ? value : [value]
    self - value
  end
end

ARY = [2,4,6,3,8] * 100_000

compare do
  soziev  { a = ARY.dup; a.delete(3);               a }
  steve   { a = ARY.dup; a -= [3];                  a }
  barlop  { a = ARY.dup; a.delete_if{ |i| i == 3 }; a }
  rodrigo { a = ARY.dup; a.rodrigo_except(3);         }
  niels   { a = ARY.dup; a.niels_except(3);           }
end

# >> Running each test once. Test will take about 6 seconds.
# >> steve is similar to soziev
# >> soziev is faster than barlop by 2x ± 0.1
# >> barlop is faster than niels by 3x ± 1.0
# >> niels is similar to rodrigo

Comments

तो, सबसे अच्छा क्या है? :)

— किर्बी

Answer 10

मैंने नील्स के समाधान में सुधार किया

class Array          
  def except(*values)
    self - values
  end    
end

अब आप उपयोग कर सकते हैं

[1, 2, 3, 4].except(3, 4) # return [1, 2]
[1, 2, 3, 4].except(4)    # return [1, 2, 3]

Comments

irbकंसोल पर काम नहीं कर रहा आपका समाधान2.2.1 :007 > [1, 2, 3, 4].except(3, 4) NoMethodError: undefined method except for [1, 2, 3, 4]:Array from (irb):7 from /usr/share/rvm/rubies/ruby-2.2.1/bin/irb:11:in <main>

— hgsongra

आईआरबी में घोषित करने के लिए, आपको एरे को विधि जोड़ने की आवश्यकता है class Array; def except(*values); self - values; end; end।

— मार्क स्वार्डस्ट्रॉम

Answer 11

आप इसे पैच भी कर सकते हैं। मुझे कभी समझ में नहीं आया कि रूबी के लिए एक exceptविधि क्यों है , Hashलेकिन इसके लिए नहीं Array:

class Array
  def except value
    value = value.kind_of(Array) ? value : [value]
    self - value
  end
end

अब आप कर सकते हैं:

[1,3,7,"436",354,nil].except(354) #=> [1,3,7,"436",nil]

या:

[1,3,7,"436",354,nil].except([354, 1]) #=> [3,7,"436",nil]

Comments

आपको value.kind_of(Array)परीक्षण की आवश्यकता नहीं है । बस उपयोग करें self - Array(value)।

— सासगोरिल्ला

Answer 12

इसलिए जब आपके पास 3 की कई घटनाएं होती हैं और आप केवल 3 की पहली घटना को हटाना चाहते हैं, तो आप बस नीचे के रूप में कुछ काम कर सकते हैं।

arr = [2, 4, 6, 3, 8, 10, 3, 12]

arr.delete_at arr.index 3

#This will modify arr as [2, 4, 6, 8, 10, 3, 12] where first occurrence of 3 is deleted. Returns the element deleted. In this case => 3.

Answer 13

पहली घटना के गैर-विनाशकारी निष्कासन:

a = [2, 4, 6, 3, 8]
n = a.index 3
a.take(n)+a.drop(n+1)

Answer 14

अगर आप भी इस डिलीट ऑपरेशन को चेनेबल बनाना चाहते हैं, तो आप कुछ आइटम को डिलीट कर सकते हैं और परिणामस्वरूप एरे पर ऑपरेशंस को चेंज करते रह सकते हैं tap:

[2, 4, 6, 3, 8].tap { |ary| ary.delete(3) }.count #=> 4

Answer 15

माणिक में हटाने के लिए सभी विभिन्न विकल्पों का संकलन

हटाएं - मिलान वाले तत्वों को मान से हटाता है। यदि एक से अधिक मान मेल खाते हैं, तो यह सभी को निकाल देगा। यदि आप घटना की संख्या के बारे में परवाह नहीं करते हैं या एकल घटना के बारे में निश्चित नहीं हैं, तो इस विधि का उपयोग करें।

a = [2, 6, 3, 5, 3, 7]
a.delete(3)  # returns 3
puts a       # return [2, 6, 5, 7]

delete_at - दिए गए सूचकांक में तत्व हटाता है। यदि आप जानते हैं कि सूचकांक इस विधि का उपयोग करता है।

# continuing from the above example
a.delete_at(2) # returns 5
puts a         # returns [2, 6, 7]

delete_if - प्रत्येक तत्व को हटाता है जिसके लिए ब्लॉक सत्य है। यह सरणी को संशोधित करेगा। ब्लॉक कहा जाता है के रूप में सरणी तुरंत बदल जाता है।

b = [1, 2, 5, 4, 9, 10, 11]
b.delete_if {|n| n >= 10}.  # returns [1, 2, 5, 4, 9]

अस्वीकार - यह नए एरे को उन तत्वों के साथ लौटाएगा जिनके लिए दिए गए ब्लॉक गलत है। इस के साथ आदेश बनाए रखा जाता है।

c = [1, 2, 5, 4, 9, 10, 11]
c.reject {|n| n >= 10}.  # returns [1, 2, 5, 4, 9]

अस्वीकार! - delete_if के समान । हो सकता है कि ब्लॉक कहे जाने पर एरियर तुरंत न बदले।

यदि आप कई मानों को सरणी से हटाना चाहते हैं, तो सबसे अच्छा विकल्प bellow है।

a = [2, 3, 7, 4, 6, 21, 13]
b = [7, 21]
a = a - b    # a - [2, 3, 4, 6, 13]