becomes => [a c e g i k]

arr = %w[a b c d e f g h i j k]
p arr.select{|x| arr.index(x) % 2 == 0}

Harry

cnt = 0
v.each { |i|
 v.delete(0) if cnt % 2 != 0
 cnt += 1

Hope that helps.

On May 9, 2008, at 8:35 AM, yermej wrote:

cfp:~ > cat a.rb

a = %w(a b c d e f g h i j k)

1.upto(a.size) do |i|
   puts '---'
   p :i => i
   p :before => a
   a.delete_at i
   p :after => a
end

cfp:~ > ruby a.rb
---
{:i=>1}
{:before=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
{:after=>["a", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
---
{:i=>2}
{:before=>["a", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
{:after=>["a", "c", "e", "f", "g", "h", "i", "j", "k"]}
---
{:i=>3}
{:before=>["a", "c", "e", "f", "g", "h", "i", "j", "k"]}
{:after=>["a", "c", "e", "g", "h", "i", "j", "k"]}
---
{:i=>4}
{:before=>["a", "c", "e", "g", "h", "i", "j", "k"]}
{:after=>["a", "c", "e", "g", "i", "j", "k"]}
---
{:i=>5}
{:before=>["a", "c", "e", "g", "i", "j", "k"]}
{:after=>["a", "c", "e", "g", "i", "k"]}
---
{:i=>6}
{:before=>["a", "c", "e", "g", "i", "k"]}
{:after=>["a", "c", "e", "g", "i", "k"]}
---
{:i=>7}
{:before=>["a", "c", "e", "g", "i", "k"]}
{:after=>["a", "c", "e", "g", "i", "k"]}
---
{:i=>8}
{:before=>["a", "c", "e", "g", "i", "k"]}
{:after=>["a", "c", "e", "g", "i", "k"]}
---
{:i=>9}
{:before=>["a", "c", "e", "g", "i", "k"]}
{:after=>["a", "c", "e", "g", "i", "k"]}
---
{:i=>10}
{:before=>["a", "c", "e", "g", "i", "k"]}
{:after=>["a", "c", "e", "g", "i", "k"]}
---
{:i=>11}
{:before=>["a", "c", "e", "g", "i", "k"]}
{:after=>["a", "c", "e", "g", "i", "k"]}

look carefully at what's happening for i >= 6.

the indexes map only by accident since each delete modifies the  
mapping in the array (size reduced by one after each delete)

On May 9, 2008, at 8:37 AM, Raúl Gutiérrez S. wrote:

cfp:~ > cat a.rb
v = %w(a b c d e f g h i j k)

cnt = 0
v.each do |i|
   puts '---'
   p :i => i
   p :before => v
   v.delete(0) if cnt % 2 != 0
   cnt += 1
   p :after => v
end

puts '==='
p v

cfp:~ > ruby a.rb
---
{:i=>"a"}
{:before=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
{:after=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
---
{:i=>"b"}
{:before=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
{:after=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
---
{:i=>"c"}
{:before=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
{:after=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
---
{:i=>"d"}
{:before=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
{:after=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
---
{:i=>"e"}
{:before=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
{:after=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
---
{:i=>"f"}
{:before=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
{:after=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
---
{:i=>"g"}
{:before=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
{:after=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
---
{:i=>"h"}
{:before=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
{:after=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
---
{:i=>"i"}
{:before=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
{:after=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
---
{:i=>"j"}
{:before=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
{:after=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
---
{:i=>"k"}
{:before=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
{:after=>["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]}
===
["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]

you cannot simultaneously iterate and delete from and enumerable in  
ruby.

On May 9, 2008, at 8:16 AM, Tim Conner wrote:

# build your index up all at once
   evens = Array.new(a.size / 2){|i| i * 2}
   ods = Array.new(a.size / 2){|i| i * 2 + 1}

# apply it
   p a.values_at(*evens)
   p a.values_at(*ods)

# apply it destructively
   a.replace a.values_at(*evens)
   p a

cfp:~ > ruby a.rb
["a", "c", "e", "g", "i"]
["b", "d", "f", "h", "j"]
["a", "c", "e", "g", "i"]

too bad compact does not do what *I* want ;).

HTH
Robert

   a = %w(a b c d e f g h i j k)

   n = (a.size/2.0).ceil
   n.times do |i|
     a[i] = a[2*i]
   end
   a.slice!(n..-1)

   p a # ==> ["a", "c", "e", "g", "i", "k"]

a = %w(a b c d e f g h i j k)
1.upto(a.size/2) {|i| a.delete_at i}

results = []

0.step(last_index, 2) do |i|
  results << letters[i]
end

letters = results
p letters

   letters.values_at(*0.step(letters.size-1,2))

using the enumerator returned from step called without a block.

David

arr = %w[a b c d b f g h i j k l m]

p arr.select{|x| arr.index(x) % 2 == 0}#> ["a", "c", "g", "i", "k", "m"]

res = []
(0...arr.length).step(2) {|x| res << arr[x]}
p res #> ["a", "c", "b", "g", "i", "k", "m"]

Harry