Cómo devolver una parte de una matriz en Ruby?
Pregunta
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 arreglos Me pregunto si hay algo similar a eso.
Solución
Sí, Rubí tiene la sintaxis de matrices sobre el tramo 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[6, 1] #=> nil
a[5, 1] #=> []
a[5..10] #=> []
Otros consejos
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]
Puede utilizar slice () para esto:
>> 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" se acaba de implementar eficazmente las matrices de crecimiento dinámico. Inserción al principio es en O (n), de inserción al final se amortiza O (1), de acceso aleatorio es O (1).
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]
Me gusta rangos para esto:
def first_half(list)
list[0...(list.length / 2)]
end
def last_half(list)
list[(list.length / 2)..list.length]
end
Sin embargo, ser muy cuidadosos acerca de si el punto final está incluido en su gama. Esto se vuelve crítica en una lista de longitud impar donde tiene que elegir dónde va a romper el medio. De lo contrario va a terminar de doble contando el elemento medio.
El ejemplo anterior pondrá consistentemente el elemento medio en el último medio.
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]