I have an array:
arr = [7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 19, 20, 21, 22, 23]
and I want to modify my array by deleting at every step of -5, i.e., arr[-5], arr[-10], arr[-15] so the original array arrafter deletion equals:
arr = [8, 9, 10, 11, 14, 15, 16, 17, 20, 21, 22, 23]
What I've been told is its not good practice to delete from an array that you're iterating through. Are there any clean solutions?
Just a modification of @tihom's answer, not relying on uniqueness, but using some ideas from "How to map with index in Ruby?":
>> arr.each_with_index.select{ |x, i| (arr.count-i)%5 != 0 }.map{ |x,i| x }
=> [8, 9, 10, 11, 14, 15, 16, 17, 20, 21, 22, 23]
Step by step it does:
.each_with_index returns an Enumerator, which yields pairs of value and its index like [7, 0], [8, 1], [9, 2], ....select{...} selects those pairs [x,i] for which count - i is not divisible by 5 (it would be all except count - 5, count - 10, etc).map{ |x,i| x } transforms each pair to just its first element.Not the most efficient, but at least clear, I think
BONUS:
I am sure that it is better to create a new array by some tranformation (in a functional-style) than modify it in-place, but if you insist on "in-place", here is a modification of @sawa's answer without hard-coded digits:
>> (-arr.count..-5).select {|i| i % 5 == 0}.each{|i| arr.delete_at(i)}
=> [-15, -10, -5]
>> arr
=> [8, 9, 10, 11, 14, 15, 16, 17, 20, 21, 22, 23]
Here we have a range from -size to -5, select only indices that are divisible by 5, and delete by them. As he said, it is important here to delete exactly in this order. But still to protect yourself from possible mistakes, I think it is safer yo never delete from an array you are iterating through and instead produce a new array (like in first method). Why complicate? ;)
(-arr.count..-5).select {|i| i % 5 == 0} could be written as (-arr.count).step(-5, 5).
Numeric#step.It is complicated to modify an array while iterating from the same side as the indices are counted. In other words, when you have positive indices, you should not iterate from the head to the tail while modifying; if you have negative indices, you should not iterate from the tail to the head. Otherwise, there is no problem.
Since you have negative indices, it is crucial that you modify from the head toward the tail.
[-15, -10, -5].each{|i| arr.delete_at(i)}
# => [8, 9, 10, 11, 14, 15, 16, 17, 20, 21, 22, 23]
Here is a simple solution:
p arr.reverse.each_slice(5).map{|x|x[0..-2]}.flatten.reverse
# => [8, 9, 10, 11, 14, 15, 16, 17, 20, 21, 22, 23]
[7, 8, 9, 10, 13, 14, 15, 16, 19, 20, 21, 22]. And that's normal. How should the 7 get dropped with your approach?
Based on the answer https://stackoverflow.com/a/19317883/908515:
arr.reverse.reject.with_index { | _, i | (i + 1) % 5 == 0 }.reverse
# i.e. arr.reverse.drop_every(5).reverse
If you want to modify the original array in-place, you can do
arr.reverse!.reject!.with_index { | _, i | (i + 1) % 5 == 0 }.reverse!
This is safe because the enumerator indices (i) are independent of the array indices.
delete_ataccepts index. Give it an index.