Scala展平会丢失所需的按大小分组的子集

与目标值相等的多维数据集总和的计数

对于少量集合，此代码有效（

target

为

100

vs

1000

）。当目标值增加时，系统将耗尽资源。我没有将

allset

展平，目的只是根据需要创建和处理较小的子集

我如何懒散地按大小创建/使用子集，直到一个大小的所有

集合

的总和等于或超过目标，在这一点上不需要再检查任何东西，因为剩余的总和将大于目标

val target = 100; val exp = 3; val maxi = math.pow(target, 1.0/exp).toInt;
target: Int = 100
exp: Int = 3
maxi: Int = 4

val allterms=(1 to maxi).map(math.pow(_,exp).toInt).to[Set];
allterms: Set[Int] = Set(1, 8, 27, 64)

val allsets = (1 to maxi).map(allterms.subsets(_).to[Vector]); allsets.mkString("\n");
allsets: scala.collection.immutable.IndexedSeq[Vector[scala.collection.immutable.Set[Int]]] = Vector(Vector(Set(1), Set(8), Set(27), Set(64)), Vector(Set(1, 8), Set(1, 27), Set(1, 64), Set(8, 27), Set(8, 64), Set(27, 64)), Vector(Set(1, 8, 27), Set(1, 8, 64), Set(1, 27, 64), Set(8, 27, 64)), Vector(Set(1, 8, 27, 64)))
res7: String =
Vector(Set(1), Set(8), Set(27), Set(64))
Vector(Set(1, 8), Set(1, 27), Set(1, 64), Set(8, 27), Set(8, 64), Set(27, 64))
Vector(Set(1, 8, 27), Set(1, 8, 64), Set(1, 27, 64), Set(8, 27, 64))
Vector(Set(1, 8, 27, 64))

allsets.flatten.map(_.sum).filter(_==target).size;
res8: Int = 1

---

此实现将丢失按大小划分的子集。

您可以通过两种方式将惰性添加到计算中：

使用

组合（）

而不是

子集（）

。这将创建一个

迭代器

，因此在需要之前不会实现组合（Int值的集合）

使用

流

（如果Scala 2.13.0，则使用

LazyList

），这样每个“行”（大小相同的组合）在需要时才会实现

然后，您可以使用每行的第一个组合将具有该行的最小

和
这一事实来修剪要实现的行数

val目标=125
val exp=2
val maxi=math.pow（target，1.0/exp）.toInt//maxi:Int=11
val allterms=（1到maxi）.map（math.pow（u，exp.toInt）
//所有术语=序号（1,4,9,16,25,36,49,64,81,100,121）
val allset=Stream.range（1，maxi+1）.map（allterms.combines）
//allset:Stream[Iterator[IndexedSeq[Int]]]=Stream（，？）
//11行，2047个组合，全部未实现
allset.map（u.map（u.sum）.buffered）//流[BufferedIterator[Int]]
.takeWhile（u.head@MarioGalic）当我尝试使用较小的值时，我可以看到所有内容，val target=10；在我看来，计数中包含的总和中缺少头：allset.takeWhile（u.buffered.head）。sum@CWHolemanII你说得对。
sum