रूबी सरणी के सभी लेकिन अंतिम तत्व

Question

मान लीजिए कि मेरे पास एक रूबी सरणी है

a = [1, 2, 3, 4]

अगर मुझे सब कुछ चाहिए लेकिन पहला आइटम, मैं लिख सकता हूं a.drop(1), जो बहुत अच्छा है। यदि मैं सभी चाहता हूं , लेकिन अंतिम आइटम, हालांकि, मैं केवल इस तरह से सोच सकता हूं

a[0..-2]   # or
a[0...-1]

लेकिन इनमें से कोई भी उपयोग करने में उतना साफ नहीं है drop। किसी भी अन्य अंतर्निहित तरीके से मैं गायब हूं?

Comments

Globalnerdy.com/2008/07/10/… के अनुसार , ड्रॉप रूबी 1.9 है, बजाय रूबी 1.8.6

— एंड्रयू ग्रिम

प्रदर्शन के बारे में क्या है .. यदि मैं पुनरावृत्तियों में इन उत्तरों का उपयोग अधिक समय तक करता रहा .. तो कौन जीतेगा?

— निनाद

दूसरे शब्दों में, कौन सा समाधान हुड के नीचे सरणी को पार नहीं करता है?

— निनाद

एक और तरीका, एक - ([a.size])

— जॉन

Answer 1

शायद ...

a = t               # => [1, 2, 3, 4]
a.first a.size - 1  # => [1, 2, 3]

या

a.take 3

या

a.first 3

या

a.pop

जो अंतिम को लौटाएगा और इसके पहले सब कुछ के साथ सरणी छोड़ देगा

या इसके खाने के लिए कंप्यूटर का काम करें:

a.reverse.drop(1).reverse

या

class Array
  def clip n=1
    take size - n
  end
end
a          # => [1, 2, 3, 4]
a.clip     # => [1, 2, 3]
a = a + a  # => [1, 2, 3, 4, 1, 2, 3, 4]
a.clip 2   # => [1, 2, 3, 4, 1, 2]

Comments

Arrayमेरे लिए सबसे अच्छा दृष्टिकोण की तरह लगने के लिए एक विधि जोड़ना । अधिकांश परियोजनाएं core_ext.rbइस तरह से कम एक्सटेंशन वाली फ़ाइल के साथ समाप्त होती हैं । कुछ पुस्तकालय व्यावहारिक रूप से इस तरह के सभी एक्सटेंशन हैं: ActiveSupportउदाहरण के लिए।

— rfunduk

यह दिलचस्प है, मुझे आश्चर्य है कि यह कितना आम है। कविता विधा के बारे में लोग क्या सोचते हैं?

— डिजिटलरॉस

कोई इस clipविधि को रूबी समुदाय को कैसे प्रस्तुत करता है ? मुझे वास्तव में लगता है कि यह वहां होना चाहिए, और बंदर-पेटिंग गलत बात है ।

— दरोगाओं

मुझे a.reverse.drop(1).reverseरणनीति पसंद है । ;-)

— एलेक्स

Answer 2

जिज्ञासा से बाहर, आपको पसंद क्यों नहीं है a[0...-1]? आप सरणी का एक टुकड़ा प्राप्त करना चाहते हैं, इसलिए टुकड़ा ऑपरेटर मुहावरेदार पसंद की तरह लगता है।

लेकिन अगर आपको इसे पूरे स्थान पर कॉल करने की आवश्यकता है, तो आपके पास हमेशा ऐरे वर्ग के लिए एक अधिक अनुकूल नाम के साथ एक विधि जोड़ने का विकल्प है, जैसे कि DigitalRoss का सुझाव दिया गया है। शायद इस तरह:

class Array
    def drop_last
        self[0...-1]
    end
end

Comments

यह बहुत सारे अव्यवस्था की तरह लगता है, जब बूंद इतनी साफ होती है। यह एक बड़ी बात नहीं है, लेकिन एक संक्षिप्त नज़र में पुष्टि करना मुश्किल है कि यह बिल्कुल सही है। मैं आपका नाम पसंद करता हूं, drop_lastवैसे ...

— पीटर

मुझे -1 का उपयोग करना बहुत पसंद है। इसके अलावा .length

— विल नाथन

जिज्ञासु, उस तीसरे का अर्थ क्या है .?

— जोशुआ पिंटर

... का मतलब अंतिम आइटम शामिल नहीं है, -1 अंतिम आइटम है। यदि आपने दो डॉट्स किए हैं, तो इसमें अंतिम आइटम, तीन डॉट्स शामिल होंगे, फिर इसमें अंतिम आइटम शामिल नहीं होगा।

— 19

सरणी की पूंछ प्राप्त करने के लिए स्लाइस ऑपरेटर का उपयोग करते हुए सावधान रहें: यह वापस आ सकता है nil: [][1..-1]-> nil, [][0...-1]->[]

— माइकल

Answer 3

एक और बेहतरीन ट्रिक

>> *a, b = [1,2,3]
=> [1, 2, 3]
>> a
=> [1, 2]
>> b
=> 3

Comments

अच्छा, पता नहीं था रूबी यह था; तो a, *b = [1,2,3]हम एक क्लासिक कार / सीडीआर फैशन में सरणी को देखेंगे।

— नोब्नोब लिट्टलुन

ईमानदारी से, मुझे उस टिप्पणी को लिखना भी याद नहीं है: D ने इसे अभी हटा दिया है ...

— पेट्र बेला

Soooo सरल और अच्छा है। THX

— microspino

Answer 4

यदि आप pop()किसी सरणी पर एक ऑपरेशन करना चाहते हैं (जो अंतिम आइटम हटाए जाने के कारण हो रहा है), लेकिन आप पॉप्ड तत्व के बजाय सरणी प्राप्त करने में रुचि रखते हैं, तो आप उपयोग कर सकते हैं tap(&:pop):

> arr = [1, 2, 3, 4, 5]
> arr.pop
=> 5
> arr
=> [1, 2, 3, 4]
> arr.tap(&:pop)
=> [1, 2, 3]

Comments

यह उत्तर वह है जो इस उपयोगकर्ता के लिए सबसे अधिक अर्थपूर्ण है। दर्पण संचालन हाथ में है और यह ऐसे शब्दों का उपयोग करता है जो व्याख्या करना आसान है && संक्षिप्त।

— जेरोम

वह कुछ चालाक रूबी है।

— बजे

Answer 5

मैं इसे इस तरह से करता हूं:

my_array[0..-2]

Comments

यह काल्पनिक रूप से काम करता है। मैं उलझन में हूं कि कई और अधिक जटिल उत्तर क्यों हैं। क्या यह एक नया रूबी जोड़ है?

— यहोशू पिंटर

@JoshuaPinter शुरुआत से ही वहां है । मैं मानता हूं कि यह अब तक का सबसे अच्छा तरीका है।

— जुलिएन

Answer 6

उदाहरण के लिए, ड्रॉप विधि को बढ़ाने के बारे में कैसे?

class Array
  def drop(n)
    n < 0 ? self[0...n] : super
  end
end

फिर आप तत्वों को अंत से हटाने के लिए एक नकारात्मक आकार का उपयोग कर सकते हैं, जैसे:

[1, 2, 3, 4].drop(-1) #=> [1, 2, 3]
[1, 2, 3, 4].drop(-2) #=> [1, 2]

Answer 7

a[0...-1]सबसे अच्छा तरीका लगता है। सरणी स्लाइस सिंटैक्स वास्तव में इस उद्देश्य के लिए बनाया गया था ...

वैकल्पिक रूप से, यदि आप जगह में सरणी को संशोधित करने में कोई आपत्ति नहीं करते हैं, तो आप बस कॉल कर सकते हैं a.pop:

>> a = [1, 2, 3, 4]
>> a.pop
>> a
=> [1, 2, 3]

Comments

आप बाद के उपयोग के लिए एक चर के लिए अंतिम तत्व भी प्रदान कर सकते हैं:b = a.pop

— विक्टर फ़ोनिक

Answer 8

शेष वापसी के साथ एक पंक्ति में अंतिम तत्व से छुटकारा पाने के लिए

[1, 2, 4, 5, 6].reverse.drop(1).reverse

वास्तव में मुश्किल,

[1,2,3,4][0..-2]
#=> [1,2,3]

Answer 9

यह रास्ता है:

[1,2,3,4,5][0..-1-1]

---

लेकिन आइए बताते हैं कि यह कैसे काम करता है:

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

अगला उदाहरण 0 स्थिति से लेकर अंतिम तक सभी रिकॉर्ड लौटाएगा

a[0..-1]
=> [1, 2, 3, 4, 5]

अगला उदाहरण 1 स्थिति से आखिरी तक रिकॉर्ड लौटाएगा

a[1..-1]
=> [2, 3, 4, 5]

और यहां आपके पास वह है जो आपको चाहिए। अगला उदाहरण 0 स्थिति से अंतिम -1 तक रिकॉर्ड लौटाएगा

a[0..-1-1]
=> [1, 2, 3, 4]

Comments

आप लिख सकते हैं -2के बजाय -1-1।

— bfontaine

आप ऐसा कर सकते हैं a[0...-1](तीसरे डॉट को नोटिस करें) और उसी परिणाम को प्राप्त करें a[0..-1-1], क्योंकि तीसरा डॉट इसे अंतिम तत्व को बाहर करने के लिए कहता है। अधिक जानकारी के लिए इसे देखें ।

— जुलिएन

Answer 10

क्या आपने "लेने" की कोशिश की है

a.take(3) 

Comments

सामान्य तौर पर, यह है a.take(a.size - 1); हां, मैंने इस विकल्प पर विचार किया।

— पीटर

Answer 11

उत्तर:, a.τwτ लेकिन आपको पहले Pyper स्थापित करना होगा ...

पाइपर इंट्रो: क्या आप लिस्फी को जानते हैं carऔर सरणी के cdr"पहले" और "आराम" कर रहे हैं? बस तुम्हारी जैसी जरूरतों के लिए, मैंने इस लिस्फी तंत्र का विस्तार किया। इसे कहा जाता है pyper, और यह आपको 2 वें तक पहुंचने की अनुमति देता है, 2 डी, 3 जी से आराम करता है, 3 डी से आराम करता है, और अंतिम भी है, अंतिम के अलावा सब कुछ है आदि के बारे में लिखने के लिए बहुत कुछ नहीं होगा, लेकिन यह भी पत्र रचना की अनुमति देता है, जैसे caar, cadr, cdadarआदि लिस्प से जाना जाता है:

# First, gem install pyper
require 'pyper'
include Pyper
a = %w/lorem ipsum dolor sit amet/
# To avoid confusion with other methods, and also because it resembles a rain gutter,
# Greek letter τ is used to delimit Pyper methods:
a.τaτ #=> "lorem"
a.τdτ #=> ["ipsum", "dolor", "sit", "amet"]
a.τbτ #=> "ipsum"
a.τeτ #=> ["dolor", "sit", "amet"]
a.τcτ #=> "dolor" (3rd)
a.τzτ #=> "amet" (last)
a.τyτ #=> "sit" (2nd from the end)
a.τxτ #=> "dolor" (3rd from the end)

और अंत में, आपके प्रश्न का उत्तर:

a.τwτ #=> ["lorem", "ipsum", "dolor", "sit"] (all except last)

वहाँ और भी है:

a.τuτ #=> ["lorem", "ipsum", "dolor"] (all except last 2)
a.τ1τ #=> ["lorem", "ipsum"] (first 2)
a.τ8τ #=> (last 2)
a.τ7τ #=> (last 3)

रचनाएं:

a.τwydτ #=> "olor" (all except 1st letter of the last word of all-except-last array)

वहाँ भी अधिक से अधिक कमांड अक्षर हैं a..f, u..zऔर 0..9, सबसे विशेष रूप से m, अर्थ नक्शा:

a.τwmbτ #=> ["o", "p", "o", "i"] (second letters of all-except-last array)

लेकिन अन्य कमांड अक्षर बहुत गर्म हैं और इस समय उपयोग करना बहुत आसान नहीं है।

Comments

मैं पहली अप्रैल को यह पढ़ रहा हूं इसलिए मैंने मान लिया कि यह एक मजाक था ... नहीं। पता नहीं रूबी के लिए यह सामान मौजूद था। :)

— जोशुआ पिंटर

Answer 12

यह मूल के अंतिम तत्वों के साथ एक नया सरणी बनाता है:

ary2 = ary.dup
ary2.pop

ध्यान दें कि कुछ अन्य लोगों ने #pop का उपयोग करने का सुझाव दिया है। यदि आप जगह में सरणी को संशोधित कर रहे हैं, तो यह ठीक है। यदि आप इसके साथ ठीक नहीं हैं, तो पहले सरणी को इस उदाहरण के अनुसार दोहराएं।

Comments

कुछ अन्य लोगों ने #pop का उपयोग करने का सुझाव दिया है, यदि आप सरणी में जगह को ठीक कर रहे हैं। यदि आप इसके साथ ठीक नहीं हैं, तो पहले सरणी को इस उदाहरण के अनुसार दोहराएं।

— अलेग्स्कोग्स

यह एक महत्वपूर्ण टिप्पणी है। आप इसे अपने उत्तर में भी जोड़ सकते हैं। चूँकि #pop के पास धमाकेदार (!) नहीं है, इस तथ्य के कारण कि यह मूल सरणी को संशोधित करता है जिससे लोग बच सकते हैं।

— mjnissim

यदि सरणी बड़ी है तो यह अक्षम है।

— juliangonzalez

Answer 13

मैं अक्सर अपने आप को एक सरणी के सभी अंतिम तत्वों को देखना चाहता हूं। मैंने अपने स्वयं के फ़ंक्शन को इस तरह से करने के लिए धांधली की है कि मुझे अन्य समाधानों की तुलना में अधिक पठनीय लगता है:

class Array
  def all_but_the_last(n)
    self.first(self.size - n)
  end
end

अब आप निम्नलिखित कर सकते हैं:

arr = ["One", "Two", "Three", "Four", "Five"]
# => ["One", "Two", "Three", "Four", "Five"]

arr.all_but_the_last(1)
# => ["One", "Two", "Three", "Four"]

arr.all_but_the_last(3)
# => ["One", "Two"]

arr.all_but_the_last(5)
# => []

arr.all_but_the_last(6)
# ArgumentError: negative array size

मैंने जानबूझकर ArgumentError की अनुमति दी है ताकि कॉल करने वाले के लिए ज़िम्मेदार हो कि वे इस पद्धति का उपयोग कैसे करते हैं। मैं इस दृष्टिकोण की टिप्पणियों / आलोचनाओं को सुनना पसंद करूंगा।

Answer 14

a = [1,2,3,4]

a[0..(a.length - 2)]
=> [1,2,3]