数组数组，到单个数组Ruby

Question

I have an array like the following:

[["red", "green", "blue"], ["small", "large", "medium"], ["loose", "tight"]]

I need to pull all of these arrays out of the parent, into separate arrays, like this:

["red", "green", "blue"] ["small", "large", "medium"] ["loose", "tight"]

The program won't always know how many child arrays will be in the parent array, because they are dynamically created.

The end goal is to take the first array (red, green, blue, etc...) and call .product on it, passing in all the following arrays, individually, so I end up with the following:

"red small loose", "red small right", "red large loose", etc..

Answer 1

This would work:

arrays = [["red", "green", "blue"], ["small", "large", "medium"], ["loose", "tight"]]

first, *others = arrays
first.product(*others).map { |s| s.join(' ') }
#=> ["red small loose", "red small tight", "red large loose", "red large tight", "red medium loose", "red medium tight", "green small loose", "green small tight", "green large loose", "green large tight", "green medium loose", "green medium tight", "blue small loose", "blue small tight", "blue large loose", "blue large tight", "blue medium loose", "blue medium tight"]

Or without temporary variables:

arrays[0].product(*arrays[1..-1]).map { |s| s.join(' ') }

Note that the argument for product is prefixed with a * . This is called the splat operator - it turns an array into an argument list.

Answer 2

I think you can do this:

2.1.0 :001 > parent_array = [["red", "green", "blue"], ["small", "large", "medium"], ["loose", "tight"]]
 => [["red", "green", "blue"], ["small", "large", "medium"], ["loose", "tight"]] 
2.1.0 :002 > first_array = parent_array.shift
 => ["red", "green", "blue"] 
2.1.0 :003 > first_array
 => ["red", "green", "blue"] 
2.1.0 :004 > parent_array
 => [["small", "large", "medium"], ["loose", "tight"]] 

# Use the splat operator (*)
2.1.0 :006 > product = first_array.product(*parent_array)
 => [["red", "small", "loose"], ["red", "small", "tight"], ["red", "large", "loose"], ["red", "large", "tight"], ["red", "medium", "loose"], ["red", "medium", "tight"], ["green", "small", "loose"], ["green", "small", "tight"], ["green", "large", "loose"], ["green", "large", "tight"], ["green", "medium", "loose"], ["green", "medium", "tight"], ["blue", "small", "loose"], ["blue", "small", "tight"], ["blue", "large", "loose"], ["blue", "large", "tight"], ["blue", "medium", "loose"], ["blue", "medium", "tight"]] 
2.1.0 :007 > result = product.map {|array| array.join(' ') }
 => ["red small loose", "red small tight", "red large loose", "red large tight", "red medium loose", "red medium tight", "green small loose", "green small tight", "green large loose", "green large tight", "green medium loose", "green medium tight", "blue small loose", "blue small tight", "blue large loose", "blue large tight", "blue medium loose", "blue medium tight"] 

Answer 3

This is one of those problems for which there is really only one good solution, here the one given by @Stefan. Still, it is fun, and possibly instructive, to try to dream up other ways. Here's a recursive approach:

arr = [["red",   "green", "blue"],
       ["small", "large", "medium"],
       ["loose", "tight"]]

def combo(arr)
  return arr.first.product(arr.last) if arr.size == 2
  combo(arr[1..-1]).flat_map { |c| arr.first.map { |f| [f, *c] } }
end

combo(arr)
  #=> [["red",   "small",  "loose"], ["green", "small",  "loose"],
  #    ["blue",  "small",  "loose"], ["red",   "small",  "tight"],
  #    ["green", "small",  "tight"], ["blue",  "small",  "tight"],
  #    ["red",   "large",  "loose"], ["green", "large",  "loose"],
  #    ...
  #    ["green", "medium", "tight"], ["blue",  "medium", "tight"]]

I have assumed that the order of the elements in the array returned is not important.