Con una lista in Python posso restituire una parte di esso utilizzando il seguente codice:Come restituire una parte di un array in Ruby?
foo = [1,2,3,4,5,6]
bar = [10,20,30,40,50,60]
half = len(foo)/2
foobar = foo[:half] + bar[half:]
Dal Rubino fa tutto in matrici Mi chiedo se c'è qualcosa di simile a questo.
Sì, Ruby ha una sintassi di allineamento molto simile a Python. Ecco la documentazione ri per il metodo indice di matrice:
--------------------------------------------------------------- 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] #=> []
È possibile utilizzare slice() per questo:
>> 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]
Tra l'altro, al meglio delle mie conoscenze, Python "liste" sono solo implementate in modo efficiente gli array crescita dinamica. L'inserimento all'inizio è in O (n), l'inserimento alla fine è ammortizzato O (1), l'accesso casuale è O (1).
Intendi utilizzare l'array di barre nel secondo segmento? – Samuel
Sì, grazie. Ho risolto questo. – Manuel
FYI: 'slice!()' Non modifica la matrice sul posto, piuttosto, "Elimina gli elementi forniti da un indice (facoltativamente fino a elementi di lunghezza) o da un intervallo." per http://ruby-doc.org/core-2.2.3/Array.html#method-i-slice-21 –
si può anche scrivere qualcosa di simile
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]
Si perde l'oggetto centrale nel caso in cui gli array abbiano una dimensione dispari. –
il mio unico punto era quello di mostrare che è possibile suddividere il primo e l'ultimo metodo di chiamata dell'array – shabunc
Il riferimento al codice potenzialmente pericoloso di @ michael-kohl è importante. Si prega di rivedere in modo che qualcuno non usi questo codice così com'è e manchi un caso limite di occorrenza di 0,5. -1 – ghayes
Se si desidera dividere/tagliare l'array su un indice i,
arr = arr.drop(i)
> arr = [1,2,3,4,5]
=> [1, 2, 3, 4, 5]
> arr.drop(2)
=> [3, 4, 5]
un altro modo è utilizzare il metodo intervallo
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]
perché un [5, 1] è diverso da [6, 1]? – dertoni
@dertoni: http://stackoverflow.com/questions/3219229/why-does-array-slice-behave-differently-for-nength-n – michelpm
'a [2 ..- 1]' per ottenere dal terzo elemento all'ultimo. 'a [2 ...- 1]' per passare dal terzo elemento fino al penultimo elemento. –