rubino/rotaie matrice tutti gli elementi tra due indici

Question

Ho un array come questo: [7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6]

Qual è il modo più semplice per tornare ogni elemento dell'array dalla posizione 6 fino 0 dove la matrice risultante assomiglia: [1,2,3,4,5,6,7]

questa posizioni nella matrice può essere dinamico, ad esempio passando 4 e 9 dovrebbero restituire [11,12,1,2,3,4]

mi sto chiedendo se c'è un metodo che realizza questo in Rails api.

Grazie in anticipo

EDIT Supponiamo che nessun numeri negativi, così facendo array[2..-2] abituato lavoro.

Array#splice quasi funziona per questo, ma se la seconda posizione è inferiore alla prima, restituisce nil.

Answer 1

class Array 
    def get_sub_array(start,last) 
     (start > last) ? (self[start..-1] + self[0..last]) : self[start..last] 
    end 
end 

Poi

a = [7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6] 
a.get_sub_array(6,0) 
#[1, 2, 3, 4, 5, 6, 7] 

O se non si vuole cerotto scimmia

Si potrebbe avere un metodo come

def get_sub_array(array, start,last) 
    (start > last) ? (array[start..-1] + array[0..last]) : array[start..last] 
end 

a = [7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6] 
get_sub_array(a,6,0) 
#[1, 2, 3, 4, 5, 6, 7] 

Answer 2

myArray = [7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6] 
myArray[6..-1] returns [1, 2, 3, 4, 5, 6] 
myArray[4..9] returns [11,12,1,2,3,4] 

Answer 3

min=6 
max=0 
arr = [7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6] 
result = [] 
if max<min 
    result << arr[min..arr.length] 
    result << arr[0..max] 
else 
    result << arr[min..max] 
end 

Answer 4

def some_function(some_array,start_val=6, end_val=0) 
    if end_val > start_val 
    some_array[start_val,(end_val - start_val)] 
    else 
    (some_array[start_val, some_array.size] << some_array[0, (end_val)]).flatten 
    end 
end 

È possibile utilizzare operatore ternario per renderlo uno di linea troppo:

def some_function(some_array,start_val=6, end_val=0) 
    end_val > start_val ? some_array[start_val,(end_val - start_val)] : (some_array[start_val, some_array.size] << some_array[0, (end_val)]).flatten 
end 

a = [7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6] 
some_function(a) # => [1, 2, 3, 4, 5, 6, 7] 
some_function(a, 4, 9) # => [11, 12, 1, 2, 3, 4] 

Answer 5

def foo a, min, max 
    a.rotate(min).first((max - min) % a.length + 1) 
end 

a = [7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6] 
foo(a, 6, 0) # => [1, 2, 3, 4, 5, 6, 7] 
foo(a, 4, 9) # => [11, 12, 1, 2, 3, 4] 

Answer 6

def foo a, s, e 
    a = e < s ? (a[s,a.size] << a[0..e]).flatten : a[s..e] 
end 

a = [7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6] 
a = foo(a, 6, 0) # => [1, 2, 3, 4, 5, 6, 7] 
a = foo(a, 4, 9) # => [11, 12, 1, 2, 3, 4] 

Answer 7

un altro paio di modi (la mia preferenza essendo per # 1).

a = [7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6] 

# 1

def foo a, min, max 
    as = a.size 
    max += as if max < min 
    (min..max).map { |i| a[i%as] } 
end 

foo(a, 6, 0) # => [ 1, 2, 3, 4, 5, 6, 7] 
foo(a, 4, 9) # => [11, 12, 1, 2, 3, 4] 

# 2

def foo a, min, max 
    max += a.size if max < min 
    e = a.cycle 
    min.times { e.next } 
    (max-min+1).times.map { e.next } 
end 

foo(a, 6, 0) # => [ 1, 2, 3, 4, 5, 6, 7] 
foo(a, 4, 9) # => [11, 12, 1, 2, 3, 4]