web-dev-qa-db-fra.com

Comment retourner une partie d'un tableau en Ruby?

Avec une liste en Python, je peux en renvoyer une partie en utilisant le code suivant:

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

Puisque Ruby fait tout dans les tableaux, je me demande s’il existe quelque chose de similaire à cela.

rubyarrayslistslice
91
Christian Stade-Schuldt

Oui, Ruby a une syntaxe de découpage de tableau très similaire à celle de Python. Voici la documentation ri pour la méthode d'indexation de tableau:

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

Si vous voulez diviser/couper le tableau sur un index i,

arr = arr.drop(i)

> arr = [1,2,3,4,5]
 => [1, 2, 3, 4, 5] 
> arr.drop(2)
 => [3, 4, 5]
23
Lenin Raj Rajasekaran

Vous pouvez utiliser slice () pour cela:

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

En passant, à ma connaissance, les "listes" Python sont simplement implémentées de manière efficace dans des tableaux à croissance dynamique. L'insertion au début est dans O (n), l'insertion à la fin est amortie O (1), l'accès aléatoire est O (1).

15
Manuel

une autre façon consiste à utiliser la méthode de la plage

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

J'aime les gammes pour cela:

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

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

Cependant, faites très attention si le noeud final est inclus dans votre plage. Cela devient critique sur une liste de longueurs impaires où vous devez choisir où vous allez briser le milieu. Sinon, vous devrez compter deux fois l'élément du milieu.

L'exemple ci-dessus mettra systématiquement l'élément du milieu dans la dernière moitié.

0
labyrinth