Boolean Array change in Ruby

Welcome to ruby. Someone nicely provided an explanation of what the issues were with your code. I thought I would give you a quick run down on the power of objects in ruby instead.

Let's start with Cat. What can it do? Well:

• It can have a hat
• It starts out without a hat
• It can put on and take off the hat

Okay so lets make an Object for that:

class Cat
  def initialize
    @hat = false # start out without a hat
  end
  def toggle_hat
    !@hat   # in case you just want to tip your hat in salutation to JörgWMittag
  end
  def toggle_hat!
    @hat = toggle_hat # @hat equals not(@hat) e.g. @hat = not(true) to take off the hat
  end
  def has_hat?
    @hat # does it have a hat true or false
  end
end

Perfect there is a Cat. Now let's look at the problem.

We need to loop through 100 cats. Okay

cats = Array.new(100) { Cat.new }

Now we have 100 cats. Let's start looping

#loop from 1 up to 100 providing the loop number (n)
1.upto(100).each do |n| 
  # for each n we skip over the preceding n and step by n
  (n..100).step(n) do |idx| 
    # pick the appropriate cat (ruby indexes start at 0) 
    # toggle his hat
    cats[idx - 1].toggle_hat!
  end
end 

Great all our Cats have been looped through and toggled now lets count the ones with hats on

# will count each cat where has_hat? is true
cats.count {|cat| cat.has_hat? }
#=> 10 

This would generally be expressed more idiomatically as cats.count(&:has_hat?). This uses ruby's Symbol#to_proc sugar and means call the method has_hat? on each element yielded to the block as shown more explicitly above.

We can also collect them

cats.map.with_index {|cat,idx| idx + 1 if cat.has_hat? }.compact
#=> [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Tada Objects are amazing and make for fantastically readable simplistic code. Full Example

cats = cats.each_with_index do |cat, idx|
  # ...
  cat = !cat
end

This is the problem. All objects in Ruby are represented in memory by pointers, and these pointers are copied around to pass objects to methods/blocks/etc. So when you do each_with_index, Ruby copies the pointer of each element into your block-local variable cat one at a time.

Now when you say cat = !cat, this is what Ruby does

1. Find the ! method for the object pointed to by cat and call it. This returns a pointer to the object true or the object false
2. Overwrite the block-local variable cat with that new pointer

At no point does that new pointer end up in your cats array!

I can think of two main solutions to this problem:

1. Instead of storing Boolean objects (which are immutable), store mutable objects in cats. Then you can call a method on each cat that tells it to mutate its state (this is what @engineersmnky's code does)
2. Instead of using your block-local variable cat, tell Ruby to copy the new pointer directly into the array: cats[idx] = !cat

def cats_in_hats
  cats = []

  i = 0
  while i < 100
    cats << false 
    i = i + 1 
  end 

  p cats 

  round = 1;

  while round < 100

  cats = cats.collect!.with_index do |cat, idx|
    idx % round == 0 ? !cat : cat
  end

  round = round + 1 

  end 

  p cats 

end

puts "------Cats in Hats------"
puts cats_in_hats

The problem with your initial code is that you were never "doing" anything in your each_with_index block. when you used cat = !cat you were only changing that item within the scope of the loop and never creating a new array. Using .collect!.with_indexmap/collect!.with_index(to get the index) you can perform an operation on each item in an array and return a new array with every iteration. This is similar to how JavaScript's map function works. Let me know if you need further explanation.