रूबी में एक सरणी के एक हिस्से को कैसे वापस करें?

Question

पायथन में एक सूची के साथ मैं निम्नलिखित कोड का उपयोग करके इसका एक हिस्सा लौटा सकता हूं:

foo = [1,2,3,4,5,6]
bar = [10,20,30,40,50,60]
half = len(foo) / 2
foobar = foo[:half] + bar[half:]

चूंकि रूबी सब कुछ सरणियों में करता है मुझे आश्चर्य है कि अगर ऐसा ही कुछ है।

Answer 1

हां, रूबी के पास पायथन के समान एक समान सरणी-स्लाइसिंग सिंटैक्स है। यहाँ riसरणी सूचकांक विधि के लिए दस्तावेज है:

--------------------------------------------------------------- Array#[]
     array[index]                -> obj      or nil
     array[start, length]        -> an_array or nil
     array[range]                -> an_array or nil
     array.slice(index)          -> obj      or nil
     array.slice(start, length)  -> an_array or nil
     array.slice(range)          -> an_array or nil
------------------------------------------------------------------------
     Element Reference---Returns the element at index, or returns a 
     subarray starting at start and continuing for length elements, or 
     returns a subarray specified by range. Negative indices count 
     backward from the end of the array (-1 is the last element). 
     Returns nil if the index (or starting index) are out of range.

        a = [ "a", "b", "c", "d", "e" ]
        a[2] +  a[0] + a[1]    #=> "cab"
        a[6]                   #=> nil
        a[1, 2]                #=> [ "b", "c" ]
        a[1..3]                #=> [ "b", "c", "d" ]
        a[4..7]                #=> [ "e" ]
        a[6..10]               #=> nil
        a[-3, 3]               #=> [ "c", "d", "e" ]
        # special cases
        a[5]                   #=> nil
        a[6, 1]                #=> nil
        a[5, 1]                #=> []
        a[5..10]               #=> []

Comments

एक [५, १] एक [६, १] से अलग क्यों है?

— डर्टोनी

@dertoni: stackoverflow.com/questions/3219229/…

— michelpm

a[2..-1]3 तत्व से पिछले एक को पाने के लिए। a[2...-1]तीसरे तत्व से दूसरे अंतिम तत्व तक पहुंचने के लिए।

— क्लेवर प्रोग्रामर

@ राफ़र चीयर्स, सोच रहा था कि यह कबाड़ कैसे काम करता है, -1 ने किया चाल

— बेन सिंक्लेयर

स्वीकृत उत्तर की तुलना में @CleverProgrammer सिंटैक्स पायथन के बहुत करीब है। मुझे रूबी से प्यार है, लेकिन मुझे कहना होगा कि पायथन का वाक्य विन्यास छोटा और स्पष्ट है। एक बोनस के रूप में, यह कदम निर्दिष्ट करना संभव है:range(10)[:5:-1]

— एरिक डुमिनील 12

Answer 2

यदि आप अनुक्रमणिका i पर सरणी को विभाजित / काटना चाहते हैं,

arr = arr.drop(i)

> arr = [1,2,3,4,5]
 => [1, 2, 3, 4, 5] 
> arr.drop(2)
 => [3, 4, 5] 

Answer 3

आप इसके लिए स्लाइस () का उपयोग कर सकते हैं :

>> foo = [1,2,3,4,5,6]
=> [1, 2, 3, 4, 5, 6]
>> bar = [10,20,30,40,50,60]
=> [10, 20, 30, 40, 50, 60]
>> half = foo.length / 2
=> 3
>> foobar = foo.slice(0, half) + bar.slice(half, foo.length)
=> [1, 2, 3, 40, 50, 60]

वैसे, मेरे ज्ञान का सबसे अच्छा करने के लिए, पायथन "सूचियों" को कुशलतापूर्वक गतिशील रूप से बढ़ते सरणियों को लागू किया जाता है। शुरुआत में प्रविष्टि O (n) में है, अंत में प्रविष्टि O (1) को परिमित किया जाता है, यादृच्छिक अभिगम O (1) है।

Comments

क्या आप दूसरे स्लाइस में बार ऐरे का उपयोग करने का मतलब है?

— शमूएल

FYI करें: slice!()सरणी को जगह में संशोधित नहीं करता है, बल्कि, यह "सूचकांक द्वारा दिए गए तत्व (ओं) को हटाता है (वैकल्पिक रूप से लंबाई तत्वों तक) या एक श्रेणी द्वारा।" प्रति रूबी-doc.org/core-2.2.3/Array.html#method-i-slice-21

— जोशुआ पिंटर

Answer 4

एक और तरीका है रेंज विधि का उपयोग करना

foo = [1,2,3,4,5,6]
bar = [10,20,30,40,50,60]
a = foo[0...3]
b = bar[3...6]

print a + b 
=> [1, 2, 3, 40, 50 , 60]

Answer 5

रूबी 2.6 शुरुआती / अंतहीन रंग

(..1)
# or
(...1)

(1..)
# or
(1...)

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

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

ROLES = %w[superadmin manager admin contact user]
ROLES[ROLES.index('admin')..]
=> ["admin", "contact", "user"]

Answer 6

मुझे इसके लिए पर्वतमाला पसंद है:

def first_half(list)
  list[0...(list.length / 2)]
end

def last_half(list)
  list[(list.length / 2)..list.length]
end

हालांकि, इस बारे में बहुत सावधान रहें कि क्या समापन बिंदु आपकी सीमा में शामिल है या नहीं। यह एक विषम-लंबाई सूची पर महत्वपूर्ण हो जाता है, जहां आपको यह चुनने की आवश्यकता होती है कि आप बीच में कहां जा रहे हैं। अन्यथा आप मध्य तत्व को दोगुना कर देंगे।

उपरोक्त उदाहरण लगातार मध्य तत्व को अंतिम छमाही में रखेगा।

Comments

(list.length / 2.0).ceilयदि आपको इसकी आवश्यकता है तो आप पहले छमाही में मध्य तत्व को लगातार डाल सकते हैं ।

— सोराशी