Cartesian product stream scala

Question

I had a simple task to find combination which occurs most often when we drop 4 cubic dices an remove one with least points.

So, the question is: are there any Scala core classes to generate streams of cartesian products in Scala? When not - how to implement it in the most simple and effective way?

Here is the code and comparison with naive implementation in Scala:

object D extends App {
  def dropLowest(a: List[Int]) = {
    a diff List(a.min)
  }

  def cartesian(to: Int, times: Int): Stream[List[Int]] = {
    def stream(x: List[Int]): Stream[List[Int]] = {
      if (hasNext(x)) x #:: stream(next(x)) else Stream(x)
    }

    def hasNext(x: List[Int]) = x.exists(n => n < to)

    def next(x: List[Int]) = {
      def add(current: List[Int]): List[Int] = {
        if (current.head == to) 1 :: add(current.tail) else current.head + 1 :: current.tail // here is a possible bug when we get maximal value, don't reuse this method
      }
      add(x.reverse).reverse
    }

    stream(Range(0, times).map(t => 1).toList)
  }

  def getResult(list: Stream[List[Int]]) = {
    list.map(t => dropLowest(t).sum).groupBy(t => t).map(t => (t._1, t._2.size)).toMap
  }

  val list1 = cartesian(6, 4)

  val list = for (i <- Range(1, 7); j <- Range(1,7); k <- Range(1, 7); l <- Range(1, 7)) yield List(i, j, k, l)
  println(getResult(list1))
  println(getResult(list.toStream) equals getResult(list1))
}

Thanks in advance

Answer 1

I think you can simplify your code by using flatMap :

val stream = (1 to 6).toStream

def cartesian(times: Int): Stream[Seq[Int]] = {
  if (times == 0) {
    Stream(Seq())
  } else {
    stream.flatMap { i => cartesian(times - 1).map(i +: _) }
  }
}

Maybe a little bit more efficient (memory-wise) would be using Iterators instead:

val pool = (1 to 6)

def cartesian(times: Int): Iterator[Seq[Int]] = {
  if (times == 0) {
    Iterator(Seq())
  } else {
    pool.iterator.flatMap { i => cartesian(times - 1).map(i +: _) }
  }
}

or even more concise by replacing the recursive calls by a fold :

  def cartesian[A](list: Seq[Seq[A]]): Iterator[Seq[A]] =
    list.foldLeft(Iterator(Seq[A]())) {
      case (acc, l) => acc.flatMap(i => l.map(_ +: i))
    }

and then:

cartesian(Seq.fill(4)(1 to 6)).map(dropLowest).toSeq.groupBy(i => i.sorted).mapValues(_.size).toSeq.sortBy(_._2).foreach(println)

(Note that you cannot use groupBy on Iterators, so Streams or even Lists are the way to go whatever to be; above code still valid since toSeq on an Iterator actually returns a lazy Stream).

If you are considering stats on the sums of dice instead of combinations, you can update the dropLowest fonction : def dropLowest(l: Seq[Int]) = l.sum - l.min