如何根据两个元素的索引合并两个数组？

Question

I'm using Ruby 2.4. I want to take an array and add its elements to an array of arrays, based on their index. So if I'm starting with an array

[1, 2, 3]

and I want to combine that with the array

[4, 5, 6]

I can get the outcome

[[1, 4], [2, 5], [3, 6]]

using this function

arr_of_arrays = arr_of_arrays.empty? ? arr : arr_of_arrays.zip(arr).map(&:flatten)

However, this breaks down if I try and add an element with more elements than the original. So if I try and add

[4, 5, 6, 7]

to the original array, right now I'm getting

[[1, 4], [2, 5], [3, 6]]

but what I want is

[[1, 4], [2, 5], [3, 6], [7]]

How do I adjust my above function to achive this?

Answer 1

From the docs:

If the size of any argument is less than the size of the initial array, nil values are supplied.

So you do not need to worry about the case where the second array is shorter.

If the first array is shorter, pad it out with nil to the length of the second array.

You can use compact to remove the superfluous nil s afterwards.

Case 1: a is longer

a = [1, 2, 3, 4, 5]
b = [6, 7, 8]

a[b.count-1] ||= nil
a.zip(b).map(&:flatten).map(&:compact)

Result:

[[1, 6], [2, 7], [3, 8], [4], [5]]

Case 2: b is longer

a = [1, 2, 3]
b = [4, 5, 6, 7, 8]

a[b.count-1] ||= nil
a.zip(b).map(&:flatten).map(&:compact)

Result:

[[1, 4], [2, 5], [3, 6], [7], [8]]   

Variation with nil included

a = [1, 2, 3, 4, 5]
b = [6, 7, 8]

a[b.count-1] ||= nil
b[a.count-1] ||= nil
a.zip(b).map(&:flatten)     # [[1, 6], [2, 7], [3, 8], [4, nil], [5, nil]]    

... and ...

a = [1, 2, 3]
b = [4, 5, 6, 7, 8]

a[b.count-1] ||= nil
b[a.count-1] ||= nil
a.zip(b).map(&:flatten)     # [[1, 4], [2, 5], [3, 6], [nil, 7], [nil, 8]]

Notes

• If a or b must not be modified, insert a .clone somewhere to clone them beforehand.
• The .flatten was taken from the OP's example; it flattens any arrays that take the role of the integers in the example. Keep or leave off as needed.

Answer 2

It looks like you want a "safe" transpose. It's called safe because the usual tranpose raises an error when sub-arrays don't have the same length :

def safe_transpose(*arrays)
  l = arrays.map(&:length).max
  arrays.map{|e| e.values_at(0...l)}.transpose.map(&:compact)
end

p safe_transpose([1, 2, 3, 4], [5, 6, 7])
#=> [[1, 5], [2, 6], [3, 7], [4]]

p safe_transpose([1, 2, 3], [4, 5, 6], [7, 8, 9])
#=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

If you want to keep the padded nils, you can use :

def safe_transpose(*arrays)
  l = arrays.map(&:length).max
  arrays.map{|e| e.values_at(0...l)}.transpose
end

p safe_transpose([1, 2, 3, 4], [5, 6, 7])
#=> [[1, 5], [2, 6], [3, 7], [4, nil]]

p safe_transpose([1, 2, 3], [4, 5, 6], [7, 8, 9])
#=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

The original arrays aren't modified.

Answer 3

I would do...

a << nil while a.length < b.length
a.zip(b).map(&:compact)

This will change your a array, though, so you may want to do the operation on a dup of a.

Answer 4

a = [1,2,3]
b = [4, 5, 6, 7]
arr_of_arrays = []

i suppose you can easily check that b.size > a.size is true, so

b.each_with_index{|elem, index| a[index].nil? ? arr_of_arrays << [elem] : arr_of_arrays << [a[index],elem]}

returns the expected array of arrays :

=> [[1, 4], [2, 5], [3, 6], [7]]

Answer 5

arr1 = [1, 2, 3]
arr2 = [4, 5, 6, 7]

def combine_two_arrays(arr1, arr2)
  new_arr = (arr1.size > arr2.size) ? arr1.zip(arr2) :  arr2.zip(arr1)
  new_arr.map { |arr| arr.compact.sort }
end 

combine_two_arrays(arr1, arr2)

Answer 6

a = [1,2,3]
b = [4,5,6,7]

Array.new([a.size, b.size].max) { |i| [a[i],b[i]].compact }
  #=> [[1, 4], [2, 5], [3, 6], [7]] 

This assumes none of the elements of a or b equal nil .

If you want nil s included, just remove .compact :

Array.new([a.size, b.size].max) { |i| [a[i],b[i]] }
  #=> [[1, 4], [2, 5], [3, 6], [nil, 7]]

In this case a and b are permitted to have nil values.