ruby ​​/ Schienen-Array alle Elemente zwischen zwei Indizes

Question

Ich habe ein Array wie folgt: [7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6]

Was ist der einfachste Weg, jedes Element in der Anordnung von Position zurückzukehren 6 bis 0, wobei die resultierende Anordnung wie folgt aussieht: [1,2,3,4,5,6,7]

diese Positionen im Array können in 4 und 9 zurückkehren sollte [11,12,1,2,3,4]

ich frage mich vorbei dynamisch, zum Beispiel, wenn ein Verfahren gibt es, dass dies in Rails api erreicht.

Vielen Dank im Voraus

EDIT Nehmen wir an, dass keine negativen Zahlen, so array[2..-2] nicht funktionieren tun.

Array#splice funktioniert fast so, aber wenn die zweite Position kleiner als die erste ist, gibt sie nil zurück.

Answer 1

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

Dann

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] 

Oder wenn Sie Affe Patch wollen nicht

könnten Sie haben eine Methode wie

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 

können Sie ternären Operator verwenden, um es zu einem Liner zu machen:

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

ein paar mehr Möglichkeiten (meine Vorliebe für # 1 zu sein).

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]