Getting a unique pair of an array using nested loops in ruby?

Question

I am currently learning ruby and am very new to it. I usually write code in javascript but because I am entering a bootcamp next year I took it upon myself to learn as much ruby before my cohort starts. So the practice problem that I'm trying to solve is getting the indices of elements that equivalent to a certain number, in which case lets give an example 0.

I can do this with no problem for JS but I am learning how to write in Ruby.

//JS 
for(let i = 0; i < arr.length; i++){
    for(let j = i + 1; j < arr.length; j++){
       if(arr[j] + arr[i] === 0){
           someVar.push([i,j]);
       }
    }
}

The block code above displays where I am getting each unique pair and which ever one of these pairs return a sum 0 their indices get pushed inside the result.

I am still very new with how ruby writes loops and there is a plethora of ways to do it.

  def two_sum(nums)
  result = []
  n = nums.length

  n.times do |i|
    n.times do |j|

      if nums[i] + nums[j] == 0
        result.push([i,j])
      end
    end
  end
  result
end

I've tried doing it this way but it doesn't give me the right output. I also understand that n.times do |j| is not the same as for(let j = i + 1; j < arr.length; j++). But I don't know how else to write this so I did something like:

n.times do |i|
  x = i + 1
  x.times do |j|

My intuition is telling me that this is not the way to write an inner loop.

Answer 1

Simply select the appropriate sums from all the pairs (combinations of 2).

def two_sum(nums)
  nums.combination(2).select{|pair| pair.sum == 3}
end

Edit: more details on what's going on:

As you know, we pass in an array called nums. If you go to the documentation for Array, you'll see a method called combination. By the way, I highly recommend that you, as a newcomer to Ruby, become familiar with all the methods on Array (as well as Enumerable, which I'll explain in a bit). The combination method "yields all combination of elements of length n" and we will use n=2:

p [3,2,1,0,5].combination(2).to_a
#=> [[3, 2], [3, 1], [3, 0], [3, 5], [2, 1], [2, 0], [2, 5], [1, 0], [1, 5], [0, 5]]

Now if you omitted the .to_a above, you'd see that the output of combination is actually an Enumerator. And if you look carefully at the documentation, you'll see under "Included Modules" it lists Enumerable. Enumerable is designed to be a "mixin", which can add methods to other classes (even your own). [Side note: In fact, if you look at the docs for Array, it includes Enumerable as well. The combination of these methods available to your Ruby arrays make them very powerful, and why I recommend learning them]. The select method takes a block and it will return all the elements for which the given block is true. So, we are checking every element to see if the sum is 3, for example:

[2,1].sum == 3
#=> true (and therefore [2,1] will be included in the output)

The output of select, and therefore the two_sum method, is an array of all the matches (the elements where the block was true).

Edit 2

It was pointed out by Stefan in the comments that the results above are returning values, not indices. One way to fix that is to add an index lookup to the results:

def two_sum(nums)
  nums.combination(2)
      .select{|pair| pair.sum == 3}
      .map{|pair| [nums.index(pair[0]), nums.index(pair[1])] }
end

Not quite as succinct, but at least it outputs indices now :)

Answer 2

If you want the code to resemble your JS snippet, then here's a version using the appropriate ruby loops.

0.upto(arr.length - 1) do |i|
  (i + 1).upto(arr.length - 1) do |j|
    if arr[i] + arr[j] == 0
      result.push([i, j])
    end
  end
end

But more idiomatic ruby would be that in MarkThomas' answer (or something similar).