How to return a part of an array in Ruby? How to return a part of an array in Ruby? arrays arrays

How to return a part of an array in Ruby?


Yes, Ruby has very similar array-slicing syntax to Python. Here is the ri documentation for the array index method:

--------------------------------------------------------------- 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]               #=> []


If you want to split/cut the array on an index i,

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


You can use slice() for this:

>> 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]

By the way, to the best of my knowledge, Python "lists" are just efficiently implemented dynamically growing arrays. Insertion at the beginning is in O(n), insertion at the end is amortized O(1), random access is O(1).