How to do a conditioned for loop in Ruby

Question

I'm amazed with Ruby's syntax, I can only describe it in one word: comfortable.

EDIT: I think I wasn't clear. I want an easy way to exit loops with conditions.

Sadly, I can't find how to do this Java code in Ruby:

Assume: array = [1,2,3,4] array2 = [1,2,3,4]

boolean condition = false;
for(int i = 0; i < array.length && !condition; i++)
{
  for(int j = 0; j < array2.length && !condition; j++)
  {
     condition = (array[i] + array2[j] + 1 == 7);
  }
}

if(condition)
{
  System.out.println("Two elements of the arrays + 1 sum 7")
}

I love Ruby's one liners... But I can't even do this with full open loops...

I'm looking for something like this (each_while is made up):

array.each_while(condition && condition2) { SomeAction }

Which is the simplest way to do this in Ruby?

Most of the loops I work with have exiting conditions to optimize them. Everything I find on the internet is not acceptable for Ruby's beautiful syntax because it is even worse than Java, and we all know Java ain't pretty.

Some solution I found in the web:

catch "BreakOuterLoop" do
  for i in 1..10
    print "out #{i}\n"
    for j in 1..10
      print "in #{j}\n"
      throw "BreakOuterLoop" if i+j > 16
    end
  end
end

Just awful...

Answer 1

Loop with condition

You could use break :

array1.each do |x|
  break unless condition && condition2
    array2.each do |y|
      break unless condition3
      # do_something
    end
  end
end

If you need the indices in your conditions :

array1.each_with_index do |x,i|
  break unless condition && condition2
    array2.each_with_index do |y,j|
      break unless condition3
      # do_something
    end
  end
end

Specific problem

Boolean

For your updated problem, you can use any?. It is exactly what you wanted to do. It iterates as long as a condition isn't true, and returns a value ASAP :

array  = [1,2,3,4]
array2 = [1,2,3,4]

puts array.product(array2).any?{|a,b| a + b + 1 == 7 }
#=> true

Or :

puts array.any?{|a| array2.any?{ |b| a + b + 1 == 7 } }
#=> true

puts array.any?{|a| array2.any?{ |b| a + b + 1 == 12 } }
#=> false

The second example should be faster, because not every pair is created : As soon as one is found, true is returned.

Pair

If you want to know for which pair the condition is true, you can use find:

p array.product(array2).find { |a, b| a + b + 1 == 7 }
#=> [2,4]

p array.product(array2).find { |a, b| a + b + 1 == 12 }
#=> nil

Optimization for huge arrays

The above code will run slow for huge arrays.

You could convert the biggest array to a Set, and use a direct lookup :

require 'set'

array  = [1, 2, 3, 4]
array2 = [1, 2, 3, 4]
set2 = array2.to_set

sum = 7 - 1
x1 = array.find { |x| set2.include?(sum - x) }

if x1
  puts "#{x1} + #{sum - x1} + 1 = #{sum + 1}"
end

#=> 2 + 4 + 1 = 7

Answer 2

require 'matrix'

Matrix[0...rows, 0...cols].each_with_index do |e, row, col|
  next unless [cond1, cond2, cond3].reduce :&
  # code
end

---

array1.each.with_index.lazy.take_while { cond1 }.each do |e1, i1|
  array2.each.with_index.lazy.take_while { cond2 }.each do |e2, i2|
    # do some stuff
  end
end

Answer 3

array.length.times do |i|
  break unless condition_1 && condition_2
  # some action
end

break will stop the loop as soon as the conditions are no longer met

Regarding the loop matrix

Of course you can nest a loop within a loops within a loop, but that is definitely not the ruby way. I'm sure there is a nicer solution to whatever problem may arise.

Answer 4

As stated before, there is a prettier functional solution for probably any specific use case you can think of. I will try to answer the more general question, which is how to convert this java code:

int somethingYouWillMutate = 0; // any types or values or number of things
for(int i = 0; i < array.length && condition && condition2; i++) {
  for(int j = 0; j < array2.length && condition; j++) {
     someAction(array[i], array2[j], somethingYouWillMutate);
  }
}

To ruby:

something_you_will_mutate = 0
array.product(array2).each do |e1, e2|
  break unless condition && condition2

  some_action(e1, e2)
end

Note:

while c1 && c2 =:=
while true; break if !(c1 && c2) =:=
while true; break unless c1 && c2

---

If you want the indices as well:

array_indexed  = array.each_with_index.to_a
array2_indexed = array2.each_with_index.to_a

array_indexed.product(array2_indexed).each do |(e1, i1), (e2, i2)|
  break unless condition && condition2

  some_action(e1, e2, i1, i2, something_you_will_mutate)
end

---

Note: If you want an even more generic solution (with 3 or more arrays for example):

[array, array2, array3...].
  map(&:each_with_index).
  map(&:to_a).
  reduce(:product).
  map(&:flatten).
  each do |e1, i1, e2, i2, e3, i3...|
    break unless condition && condition2 && condition3...

    some_action(e1, e2, i1, i2, e3, i3..., something_you_will_mutate)
  end