Question

我有一个简单的任务来找到最常出现的组合，当我们丢弃4个立方体骰子时，删除一个点数最少。

所以，问题是：是否有任何Scala核心类可以在Scala中生成笛卡尔积的流？什么时候不 - 如何以最简单有效的方式实现它？

以下是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))
}

提前致谢

Answer 1

我认为您可以使用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 +: _) }
  }
}

可能更有效（内存方面）将使用迭代器：

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 +: _) }
  }
}

通过折叠替换递归调用

或者更简洁：

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

然后：

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

（请注意，你不能在迭代器上使用groupBy，因此Streams甚至Lists都可以实现;上面的代码仍然有效，因为Iterator上的toSeq实际上返回了一个惰性流。）

如果您正在考虑骰子总数而不是组合的统计数据，您可以更新dropLowest功能： def dropLowest(l: Seq[Int]) = l.sum - l.min

笛卡儿积流scala

1 个答案: