yakut/raylar dizisi iki endeks arasındaki tüm unsurları

Question

Ben böyle bir dizi: [7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6]

çıkan dizi benziyor 0 olana kadar pozisyon 6'dan dizideki her öğeyi döndürmek için basit yolu nedir: [1,2,3,4,5,6,7]

dizideki

Bu pozisyonları 4'te geçen örneğin, dinamik olabilir ve 9 Raylar API bu işlevi gören yöntem olmadığını merak ediyorum [11,12,1,2,3,4]

dönmelidir. peşin

DÜZENLEME içinde

Teşekkür en olumsuz rakamlar, bu nedenle array[2..-2] alışkanlık işi kabul edelim.

Array#splice neredeyse bunun için çalışır, ancak ikinci konum ilkinden daha azsa, nil değerini döndürür.

Answer 1

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

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] 

Eğer maymun yama

istemiyorsanız eğer

Veya

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 

tek bir astar da bunu yapmak için üçlü operatörü kullanabilirsiniz: Sonra

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

Birkaç tane daha yolları (benim tercihi # 1 olmak üzere) gibi bir yöntem olabilir.

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]