¿Cómo devolver una parte de una matriz en Ruby?

Question

Con una lista en Python puedo devolver una parte de ella usando el siguiente código:

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

Desde Rubí hace todo en matrices Me pregunto si hay algo similar a eso.

Answer 1

Sí, Ruby tiene una sintaxis de corte de matriz muy similar a Python. Aquí está la documentación ri para el método de índice de matriz:

--------------------------------------------------------------- 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[5, 1]    #=> [] 
     a[5..10]    #=> [] 

Answer 2

Se puede utilizar para este slice():

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

Por cierto, a lo mejor de mi conocimiento, Python "listas" son implementadas de manera eficiente las matrices de crecimiento dinámico. La inserción al comienzo está en O (n), la inserción al final se amortiza O (1), el acceso aleatorio es O (1).

Answer 3

También puede escribir algo como esto

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] 

Answer 4

Si desea dividir/cortar la matriz en un índice i,

arr = arr.drop(i) 

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

Answer 5

Otra forma es utilizar el método de rango

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]