ruby ​​/ szyny tablicy wszystkie elementy pomiędzy dwoma indeksami

Question

Mam tablicę tak: [7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6]

Co to najprostszy sposób, aby powrócić każdego elementu w tablicy z pozycji 6 aż 0 gdzie powstały tablica wygląda następująco: [1,2,3,4,5,6,7]

Te pozycje w tablicy może być dynamiczna, na przykład przechodzącą w 4 i 9 powinny powrócić [11,12,1,2,3,4]

Zastanawiam się, czy jest jakiś sposób, który realizuje to w Rails API.

góry dzięki

EDIT Załóżmy, że żadne negatywne numery, więc robi array[2..-2] przyzwyczajenie praca.

Array#splice prawie to działa, ale jeśli druga pozycja jest mniejsza niż pierwsza, zwraca nil.

Answer 1

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

Następnie

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] 

Lub jeśli nie chcesz małpa plastra

Można mieć metody takie jak

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 

Można użyć operatora potrójny aby jeden liner też:

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

jeszcze kilka sposobów (moja preferencja jest dla # 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]