Scala: Cartesian product between a variable number of Arrays

Question

I am a newbie in Scala and would appreciate any direction or help in solving the following problem.

Input

I have a Map[String, Array[Double]] that looks like follow:

Map(foo -> Array(12, 25, 100), bar -> Array(0.1, 0.001))

The Map can contain between 1 and 10 keys (depends on the some parameters in my application).

Processing

I would like to apply a cartesian product between the arrays of all keys and generate a structure that contains all the possible combinations of all values of all arrays.

In the example above, the cartesian product will create 3x2=6 different combinations: (12, 0.1), (12, 0.001), (25, 0.1), (25, 0.01), (100,0.1) and (100, 0.01).

For the sake of another example, in some cases I might have three key: the first key has an Array of 4 values, the second has an Array of 5 values and the third has an Array of 3 values, in this case the product has to generate 4x5x3=60 different combinations.

Desired output

Something like:

Map(config1 -> (foo -> 12, bar -> 0.1), config2 -> (foo -> 12, bar -> 0.001), config3 -> (foo -> 25, bar -> 0.1), config4 -> (foo -> 25, bar -> 0.001), config5 -> (foo -> 100, bar -> 0.1), config6 -> (foo -> 100, bar -> 0.001))

What solutions have you considered/tried so far? – Dima Jan 13 '16 at 11:48 — Dima, Jan 13 '16 at 11:48
TBH, none, any solution would be highly appreciated – Rami Jan 13 '16 at 11:49 — Rami, Jan 13 '16 at 11:49

score 1 · Accepted Answer · answered Jan 13 '16 at 12:18

You can use a for comprehension to create a cartesian product of two lists, arrays, ...

val start = Map(
  'foo -> Array(12, 25, 100), 
  'bar -> Array(0.1, 0.001), 
  'baz -> Array(2))

// transform arrays into lists with values paired with map key
val pairedWithKey = start.map { case (k,v) => v.map(i => k -> i).toList }

val accumulator = pairedWithKey.head.map(x => Vector(x))
val cartesianProd = pairedWithKey.tail.foldLeft(accumulator)( (acc, elem) => 
  for { x <- acc; y <- elem } yield x :+ y 
)

cartesianProd foreach println
// Vector(('foo,12), ('bar,0.1), ('baz,2))
// Vector(('foo,12), ('bar,0.001), ('baz,2))
// Vector(('foo,25), ('bar,0.1), ('baz,2))
// Vector(('foo,25), ('bar,0.001), ('baz,2))
// Vector(('foo,100), ('bar,0.1), ('baz,2))
// Vector(('foo,100), ('bar,0.001), ('baz,2))

You might want to add some checks before using head and tail.

Thanks for the neat solution Peter – Rami Jan 13 '16 at 12:26 — Rami, Jan 13 '16 at 12:26

score 1 · Answer 2 · answered Jan 13 '16 at 19:38

Since the number of Arrays is dynamic, there is no way you can get tuples as the result.

You can, however, utilize recursion for your purpose:

def process(a: Map[String, Seq[Double]]) = {
    def product(a: List[(String, Seq[Double])]): Seq[List[(String, Double)]] =
        a match {
            case (name, values) :: tail =>
                for {
                    result <- product(tail)
                    value <- values
                } yield (name, value) :: result

            case Nil => Seq(List())
        }

    product(a.toList)
}


val a = Map("foo" -> List(12.0, 25.0, 100.0), "bar" -> List(0.1, 0.001))
println(process(a))

Which gives a result of:

List(List((foo,12.0), (bar,0.1)), List((foo,25.0), (bar,0.1)), List((foo,100.0), (bar,0.1)), List((foo,12.0), (bar,0.001)), List((foo,25.0), (bar,0.001)), List((foo,100.0), (bar,0.001)))

Scala: Cartesian product between a variable number of Arrays

2 Answers2