如何获得 Scala 中两个列表的平方和？

Question

如果我有两个列表，

val first = List(1, 2, 3)
val second = List(4, 5, 6)

我如何获得以下内容？

(1-4)^2 + (2-5)^2 + (3-6)^2

Answer 1

zip、ma​​p 和 sum：

first.view.zip(second).map(t => t._1 - t._2).map(x => x*x).sum

• zip 将两个列表的元素组合成一个元组
• view 用于延迟计算列表，以便不在两个映射调用之间构建结构

（编辑以 sum 替换 reduceLeft））

---

看到评论后，我觉得我必须回来解释一下视图。基本上，视图将 Traversable 转换为类似迭代器的结构，以便在应用 map、zip 等方法时不必创建多个中间结构> 以及其他一些。 GenIteratableViewLike 的类型成员给人一种哪些操作有特殊处理。因此，通常如果您有一堆按顺序应用的 map、filter、drop、takeWhile，您可以使用 view 来获得一些性能。经验法则是尽早应用 view 以最大程度地减少创建的中间 List 数量，如有必要，在最后使用 force 返回到List（或您正在使用的任何集合）。这就是丹尼尔的建议。

关于性能的问题是，在实践中，如果这很重要，你就必须进行现实检查。以下是一些数字（越低越好）：

no view List(62, 62, 62, 62, 63) sum: 311
view before zip List(32, 31, 15, 16, 31) sum: 125
view after zip List(31, 46, 46, 31, 31) sum: 185
iterator List(16, 16, 16, 16, 15) sum: 79
zipped List(62, 47, 62, 46, 47) sum: 264

代码在这里：

import testing.Benchmark

def lots[T](n: Int, f: => T): T = if (n > 0) { f; lots(n - 1, f) } else f

def bench(n: Int, id: String)(block: => Unit) {
  val times = (new testing.Benchmark { 
    def run() = lots(10000, block)
  }).runBenchmark(n)
  println(id + " " + times + " sum: " + times.sum)
}

val first = List(1, 2, 3)
val second = List(4, 5, 6)

bench(5, "no view") { first.zip(second).map(t => t._1 - t._2).map(x => x*x).sum }
bench(5, "view before zip") { first.view.zip(second).map(t => t._1 - t._2).map(x => x*x).sum }
bench(5, "view after zip") { first.zip(second).view.map(t => t._1 - t._2).map(x => x*x).sum }
bench(5, "iterator") { first.iterator.zip(second.iterator).map(t => t._1 - t._2).map(x => x*x).sum }
bench(5, "zipped") { (first, second).zipped.map((a,b) => a - b).map(x => x*x).sum }

Answer 2

一般来说，如果函数很复杂，您可能想要定义一个函数，而不是应用多个映射。您可以将其作为辅助方法执行，或者以匿名方式内联执行。

def op(i: Int, j: Int) = { val m = i - j; m * m }

(first, second).zipped.map(op).sum

或者

(first, second).zipped.map( (i, j) => { val m = i - j; m * m } ).sum

在这些情况下 zipped 比 zip 更方便，因为它可以映射到带有 2 个参数的函数，而不是必须使用的单个元组._1 和 ._2 字段。

Answer 3

向左折叠：

(0 /: first.zip (second)) ((a, b) => a + (b._1 - b._2)*(b._1 - b._2))

从拉链开始。