Wie ein Teil eines Arrays in Ruby zurück?

Question

Mit einer Liste in Python ich einen Teil davon mit dem folgenden Code zurückgeben kann:

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

Da Rubin tut alles in Arrays Ich frage mich, wenn es etwas ähnlich.

Answer 1

Ja, Ruby hat sehr ähnliche Array-Slicing-Syntax zu Python. Hier ist die ri Dokumentation für die Array-Index-Methode:

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

Answer 2

Wenn Sie möchten, teilen / schneiden Sie das Array auf einem Index i,

arr = arr.drop(i)

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

Answer 3

Sie können mit slice () für diese:

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

Durch die Art und Weise, auf die besten meines Wissens, Python „Listen“ sind nur effizient dynamisch wachsenden Arrays implementiert. Insertion am Anfang ist in O (n), Einfügung am Ende amortisiert O (1), einen Direktzugriffs ist O (1).

Answer 4

eine andere Art und Weise ist der Bereich Methode zu verwenden,

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

Ich mag Bereiche für diese:

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

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

Allerdings sehr vorsichtig sein, ob der Endpunkt in Ihrem Bereich enthalten ist. Dies wird kritisch auf einer ungeraden Länge Liste, wo Sie brauchen, um zu wählen, wo Sie gehen in der Mitte zu brechen. Ansonsten finden Sie das mittlere Element am Ende doppelt zu zählen.

Das obige Beispiel konsequent das mittlere Element in der letzten Hälfte setzen.

Answer 6

Sie können auch so etwas schreiben

foo = [1,2,3,4,5,6,7]
bar = [10,20,30,40,50,60,70]
half = foo.length / 2
foobar = (foo.first half) + (bar.drop half)

=> [1, 2, 3, 40, 50, 60, 70]