Ruby sums of objects in array equal to zero [closed] - ruby

Question

This question is unlikely to help any future visitors; it is only relevant to a small geographic area, a specific moment in time, or an extraordinarily narrow situation that is not generally applicable to the worldwide audience of the internet. For help making this question more broadly applicable, visit the help center.
Closed 9 years ago.
Write a method that finds if an array of numbers has a pair that sums to zero. Be careful of the case of zero; there needs to be two zeroes in the array to make a pair that sums to zero.
Below is the code that I wrote, but I know that it is wrong. I know that at some point it will be adding itself so if there is only one 0 in my array, then it will still return true. I am new to programming and Ruby so any advice will be really appreciated.
Thanks!
def has_zero?(array)
left, right = [-1,1]
lefter=[]
righter=[]
righter=array.each {|x| x+= array[right]}
lefter=array.each {|x| x+= array[left]}
if lefter.include?(0) || righter.include?(0)
return true
else return false
end
left,right = [left-1,right+1]
end

Answer 1

Ruby has some built-in methods that make this pretty easy:
def has_zero_sum_pair?(a)
a.permutation(2).any?{|pair| pair.inject(:+) == 0}
end
a.permutation(2) gives you every pair in a. any? returns true if the block ever returns true. inject(:+) is an easy way to get the sum of an array.
has_zero_sum_pair?([1, 2, 3])
# => false
has_zero_sum_pair?([1, 2, 3, -2])
# => true
has_zero_sum_pair?([1, 2, 3, 0])
# => false
has_zero_sum_pair?([0, 1, 2, 3, 0])
# => true
Update: If I didn't know about Array#permutation and had to accomplish this in the first way that came to mind, or if I was concerned about performance, I'd probably do something like this:
def has_zero_sum_pair2?(a)
(0..a.length-2).each do |i|
(i+1..a.length-1).each do |j|
return true if a[i] + a[j] == 0
end
end
false
end
I find that uglier and more error-prone, and it took longer to write. But it's about four times faster with small arrays and 10 times faster for larger arrays. It's typical in programming to have an easy way that works well enough in most cases but isn't ideal in performance. Sometimes better performance can be attained without costing clarity by choosing a better algorithm or data structure. Often a trade-off has to be made.
Update 2: If I really cared about performance, I'd use #FMc's technique. That's a great example of using a better data structure and algorithm for huge performance gains.

Answer 2

This works except for zero.
[1, 2, 3, -2]
.uniq.group_by(&:abs).any?{|_, tuple| tuple.length == 2}
# => true

Answer 3

array = [1,2,3,-2,0,0]
array.any?{|a| array.rindex(-a) > array.index(a)}
Check to see if the negative of any item is further to the right in the array. (rindex finds the index of the last occurance in the array.)

Answer 4

This problem calls for a Hash.
vals = [0, 4, 3, 0, -3, 2, -2, 1, 3, -4, -4]
# Our hash:
# groups[X] = Array of vals equal to X
groups = vals.group_by { |v| v }
# Just check whether the hash contains a pair
# of keys X and -X, or whether the original array
# had more than one zero in it.
p groups.any? { |k, vs| k == 0 ? vs.size > 1 : groups.has_key?(-k) }
You can generalize to any target sum by changing the test slightly:
k == target / 2 ? vs.size > 1 : groups.has_key?(target - k)