Question

因为我有一个集合：

List(1, 3,-1, 0, 2, -4, 6)

很容易将其排序为：

List(-4, -1, 0, 1, 2, 3, 6)

然后我可以通过计算6-3,3-2,2-1,1-0等构建一个新的集合，依此类推：

for(i <- 0 to list.length -2) yield {
    list(i + 1) - list(i)
}

并获得一个矢量：

Vector(3, 1, 1, 1, 1, 3)

也就是说，我想让下一个元素减去当前元素。

但是如何在Spark上的RDD中实现它？

我知道这个系列：

List(-4, -1, 0, 1, 2, 3, 6)

集合中会有一些分区，每个分区都是有序的，我可以对每个分区进行类似的操作，并在每个分区上收集结果吗？

Answer 1

最有效的解决方案是使用sliding方法：

import org.apache.spark.mllib.rdd.RDDFunctions._

val rdd = sc.parallelize(Seq(1, 3,-1, 0, 2, -4, 6))
  .sortBy(identity)
  .sliding(2)
  .map{case Array(x, y) => y - x}

Answer 2

假设您有类似

的内容

val seq = sc.parallelize(List(1, 3, -1, 0, 2, -4, 6)).sortBy(identity)

让我们创建第一个集合，其中索引为关键，如Ton Torres建议

val original = seq.zipWithIndex.map(_.swap)

现在我们可以构建一个元素移位的集合。

val shifted = original.map { case (idx, v) => (idx - 1, v) }.filter(_._1 >= 0)

接下来，我们可以计算按索引递减排序的所需差异

val diffs = original.join(shifted)
      .sortBy(_._1, ascending = false)
      .map { case (idx, (v1, v2)) => v2 - v1 }

所以

 println(diffs.collect.toSeq)

显示

WrappedArray(3, 1, 1, 1, 1, 3)

请注意，如果逆转并不重要，您可以跳过sortBy步骤。

另请注意，对于本地收集，这可以更加简单地计算：

val elems = List(1, 3, -1, 0, 2, -4, 6).sorted  

(elems.tail, elems).zipped.map(_ - _).reverse

但是在RDD的情况下，zip方法要求每个集合应包含每个分区的相等元素计数。因此，如果您要实施tail之类的

val tail = seq.zipWithIndex().filter(_._2 > 0).map(_._1)

tail.zip(seq)不起作用，因为两个集合都需要等于每个分区的元素数量，并且每个分区都有一个元素应该传递到前一个分区。

在Spark

2 个答案: