All combinations of positive and negative values of an array in Ruby - ruby

Question

I am wondering how to get an array in Ruby with all combinations of positive and negative values based on the values in an input array. Order does not matter, but must be accommodating to input arrays of all sizes. It must be flexible so negative numbers could be in the input, even though I didn't include them in the example below.
For example:
input:
a = [1,2,3,4]
output:
b = [[1,2,3,4],[1,2,3,-4],[1,2,-3,-4],[-1,2,-3,-4]...[1,-2,3,-4],[1,-2,-3,-4],[-1,-2,-3,-4],[-1,-2,-3,4],[-1,-2,3,4],[-1,2,3,4]]
Your help is much appreciated!

Answer 1

You'll notice, as you iterate through the positives and negatives, that the pattern with which you apply the negativity is the same as the pattern you would use to increment bits as you count in binary. This is because each index in the array can have one of two values (positive or negative), just like each bit in a binary number can have one of two values (0 or 1). So, the easy solution is to map 0 and 1 to positive and negative. Then we can just do normal Ruby iterating, and check the bit at the element's corresponding index.
a = [1,2,3,4] # => [1, 2, 3, 4]
signed = [a, a.map(&:-#)] # => [[1, 2, 3, 4], [-1, -2, -3, -4]]
(0...2**a.size).each do |n| # => 0...16
p Array.new(a.size) { |i| signed[n[i]][i] } # => [1, 2, 3, 4], [-1, 2, 3, 4], [1, -2, 3, 4], [-1, -2, 3, 4], [1, 2, -3, 4], [-1, 2, -3, 4], [1, -2, -3, 4], [-1, -2, -3, 4], [1, 2, 3, -4], [-1, 2, 3, -4], [1, -2, 3, -4], [-1, -2, 3, -4], [1, 2, -3, -4], [-1, 2, -3, -4], [1, -2, -3, -4], [-1, -2, -3, -4]
end # => 0...16
# >> [1, 2, 3, 4]
# >> [-1, 2, 3, 4]
# >> [1, -2, 3, 4]
# >> [-1, -2, 3, 4]
# >> [1, 2, -3, 4]
# >> [-1, 2, -3, 4]
# >> [1, -2, -3, 4]
# >> [-1, -2, -3, 4]
# >> [1, 2, 3, -4]
# >> [-1, 2, 3, -4]
# >> [1, -2, 3, -4]
# >> [-1, -2, 3, -4]
# >> [1, 2, -3, -4]
# >> [-1, 2, -3, -4]
# >> [1, -2, -3, -4]
# >> [-1, -2, -3, -4]

Answer 2

Another way (a variant of #JoshuaCheek's answer):
a = [1,2,3,4]
n = a.size
(2**n).times.map { |i|
("%0#{n}b" % i).split('').zip(a).map { |b,e| (b=='1') ? e : -e } }
#=> [[-1, -2, -3, -4], [-1, -2, -3, 4], [-1, -2, 3, -4], [-1, -2, 3, 4],
# [-1, 2, -3, -4], [-1, 2, -3, 4], [-1, 2, 3, -4], [-1, 2, 3, 4],
# [ 1, -2, -3, -4], [ 1, -2, -3, 4], [ 1, -2, 3, -4], [ 1, -2, 3, 4],
# [ 1, 2, -3, -4], [ 1, 2, -3, 4], [ 1, 2, 3, -4], [ 1, 2, 3, 4]]

Answer 3

While other answers already dabbled in the Array methods, Array#repeated_permutation is what is really needed here:
[ 1, -1 ].repeated_permutation( 4 ).map { |p| [ 1, 2, 3, 4 ].zip( p ).map { |u, v| u * v } }

Answer 4

The below approach works - basically, we use a bit mask between binary 0000 to 1111 (or decimal 0 to 15) to decide which numbers should be negative (0 is positive, 1 is negative) - more details in the comments in the code below :
require 'pp'
result = []
# consider binary number mask from binary 0000 to 1111,
# where each digit if 0 uses the positive number, and if 1 uses the negative number
(0..15).each do |mask|
combin = [] # each combination
# Next, loop through the four place values (1,2,4,8)
(0..3).each do |pwr|
pv = 2 ** pwr # each place value
if ((mask & pv) == pv) # if the mask has the bit set at this place value,
combin << -(pwr + 1) # use the negative of the number (pwr + 1 gives 1, 2, 3, 4 nicely)
else # if mask doesn't have the bit set at this place value
combin << (pwr + 1) # use the positive value of the number
end
end
result << combin
end
pp result
# Output:
# [[1, 2, 3, 4],
# [-1, 2, 3, 4],
# [1, -2, 3, 4],
# [-1, -2, 3, 4],
# [1, 2, -3, 4],
# [-1, 2, -3, 4],
# [1, -2, -3, 4],
# [-1, -2, -3, 4],
# [1, 2, 3, -4],
# [-1, 2, 3, -4],
# [1, -2, 3, -4],
# [-1, -2, 3, -4],
# [1, 2, -3, -4],
# [-1, 2, -3, -4],
# [1, -2, -3, -4],
# [-1, -2, -3, -4]]

Answer 5

array=[]
[1,-1].each do |a|
[2,-2].each do |b|
[3,-3].each do |c|
[4,-4].each do |d|
array<<[a,b,c,d]
end
end
end
end
I'll elaborate on a more complete amswer as soon as I get my hands on a keyboard
Update:
A lot of good answer, here is the recursive way:
#input = [1,2,3,4] # or whatever
#output = []
def pos_neg(ind,in_array)
a=#input[ind]
[a,-a].each do |b|
arr=in_array.dup
arr[ind]=b
if #input.size > ind+1
pos_neg(ind+1,arr)
else
#output << arr
end
end
end
Then, you run:
pos_neg(0,[])
#output
[[1, 2, 3, 4],
[1, 2, 3, -4],
[1, 2, -3, 4],
[1, 2, -3, -4],
[1, -2, 3, 4],
[1, -2, 3, -4],
[1, -2, -3, 4],
[1, -2, -3, -4],
[-1, 2, 3, 4],
[-1, 2, 3, -4],
[-1, 2, -3, 4],
[-1, 2, -3, -4],
[-1, -2, 3, 4],
[-1, -2, 3, -4],
[-1, -2, -3, 4],
[-1, -2, -3, -4]]

Answer 6

Well, Ruby conveniently includes a combination method on the Array object, but first you need to create the opposite values for the numbers in the original array:
a = [1,2,3,4]
b = a.map(&:-#)
Then you'd want to concatenate the two arrays into a single array:
c = a + b
And finally you can call the combination method of the array that contains all the positive and negative values:
c.combination(4).to_a # => [[1,2,3,4], [1,2,3,-1], ...]
Here is the documentation for the combination method.
Update: I like what Boris Stitnicky came up with. Here's a variation on that:
a = [1,2,3,4]
def sign_permutations(arr)
[1, -1].repeated_permutation(arr.length).map do |signs|
signs.map.with_index do |sign, index|
arr[index] * sign
end
end
end
puts sign_permutations(a).inspect