标签: foldleft

我想知道foldLeft地图是如何工作的.如果我有一个List并使用零元素和函数调用foldLeft,我确实理解它是如何工作的:

val list1 = List(1,2,3)
list1.foldLeft(0)((a,b) => a + b)

我0用第一个元素添加零元素list1然后添加第二个元素,list1依此类推.因此输出成为新输入,第一个输入是零元素.

现在我得到了代码

val map1 = Map(1 -> 2.0, 3 -> 4.0, 5 -> 6.2) withDefaultValue 0.0
val map2 = Map(0 -> 3.0, 3 -> 7.0) withDefaultValue 0.0
def myfct(terms: Map[Int, Double], term: (Int, Double)): Map[Int, Double] = ???

map1.foldLeft(map2)(myfct)

1. 所以我的第一个元素是a Tuple2,但既然map2是a Map而不是a Tuple2,那么零元素是什么？
2. 当我们有一个List,即list1,我们总是"采取下一个元素list1".什么是"下一个元素map1？它是另一对map1吗？

我有一个类型的值,Seq[Array[Int]]我想最终得到一个Array[Int].我认为foldLeft会起作用,但令人惊讶的是它没有:

scala> val arr1 = Array(1,2,3)
arr1: Array[Int] = Array(1, 2, 3)

scala> val arr2 = Array(4,5,6)
arr2: Array[Int] = Array(4, 5, 6)

scala> val seq = Seq( arr1, arr1 )
seq: Seq[Array[Int]] = List(Array(1, 2, 3), Array(1, 2, 3))

scala> seq.foldLeft ( Array.empty )( (x,y) => x ++ y )
<console>:17: error: value ++ is not a member of Array[Nothing]
       seq.foldLeft ( Array.empty )( (x,y) => x ++ y )
                                                ^

这个错误似乎不是完整的事实,因为我可以这样做:

scala> Array.empty
res22: …

我有以下代码片段：

import scala.io.Source
object test extends App {

  val lineIterator = Source.fromFile("test1.txt").getLines()


  val fileContent = lineIterator.foldLeft(List[String]())((list, currentLine) => { 
    currentLine :: list
    list
    })


    fileContent foreach println

}

假设test1.txt文件不为空，并且其中包含一些值。所以我对foldLeft函数的问题是，为什么此示例在此返回一个空列表，而当我list在foldLeft函数末尾删除时，它可以正常工作？为什么在值下返回一个空列表fileContent？

使用. 实现 Haskelltake和drop函数foldl。

关于如何使用foldl??实现 take 和 drop 功能有什么建议吗？

take x ls = foldl ???

drop x ls = foldl ???

我已经尝试过这些，但它显示错误：

myFunc :: Int -> [a] -> [a]
myFunc n list = foldl func [] list
    where 
    func x y | (length y) > n = x : y 
             | otherwise      = y

产生错误：

*** Expression : foldl func [] list
*** Term : func
*** Type : a -> [a] -> …

我有要求在哪里我想要列表中所有员工薪水的总和

employeeList.foldLeft(java.math.BigDecimal.ZERO) { (accSal,emp) => accSal + getSalary(emp,designation,yearsOfExp) }

在这里，我想为每个员工调用一个函数getSalary，并对返回值求和以获取所有员工的薪水

上面的代码似乎对我不起作用，不断出错

Type mismatch expected:String actual:BigDecimal

我正在试图找出按序列执行一系列期货的最佳方式,其中一个Future的执行取决于之前的.我试图为任意数量的期货做这件事.

用户案例:

• 我从我的数据库中检索了许多ID.
• 我现在需要检索Web服务上的一些相关数据.
• 一旦我找到了有效的结果,我想停止.
• 我只关心成功的结果.

并行执行这些并且然后解析返回的结果集合不是一种选择.我必须一次执行一个请求,并且只有在前一个请求没有返回任何结果时才执行下一个请求.

目前的解决方案是沿着这些方向.使用foldLeft执行请求,然后仅在前一个未来满足某些条件时评估下一个未来.

def dblFuture(i: Int) = { i * 2 }
val list = List(1,2,3,4,5)
val future = list.foldLeft(Future(0)) {
  (previousFuture, next) => {
    for {
      previousResult <- previousFuture
      nextFuture <- { if (previousResult <= 4) dblFuture(next) else previousFuture }
    } yield (nextFuture)
  }
}

这方面的一个重大缺点是:a)我一直处理所有项目,即使我得到了一个我很满意的结果,并且b)一旦我找到了我想要的结果,我就会继续评估谓词.在这种情况下,它是一个简单的if,但实际上它可能更复杂.

我觉得我错过了一个更优雅的解决方案.

我给的函数foldl是以中缀方式应用的吗？

例

foldl (-) 0 [1,2,3]

= 0-1-2-3 
= -6

更一般地说:

foldl f x [a,b,c]

适用于:

(((x `f` a) `f`  b) `f` c)

我知道它是递归的,但我可以这样思考吗？

我有一个元组列表，我想总结哪些元素：

val t = Seq(1,2,3,4,5).map(el => (el,1))
t: Seq[(Int, Int)] = List((1,1), (2,1), (3,1), (4,1), (5,1))

t.foldLeft(0,0){ case ((a,b),(c,d)) => (a+b,c+d)}
res3: (Int, Int) = (14,6)

答案(14,6)确实是出乎意料的（预期是(15,5)）。

更令我困惑的是：

t.foldLeft(0,1){ case ((a,b),(c,d)) => (a+b,c+d)}
res3: (Int, Int) = (15,6)

我的问题是参数foldLeft(x,y)对应于什么（它们是第一和第二折的初始参数？），以及如何在元组的第一和第二元素上获得所需的总和。

是否可以通过Scala中的map和filter的某种组合替换foldLeft函数？例如,关于此任务.

输入是三元组列表(学生姓名,课程,年级):

val grades = List(("Hans", "db", 2.3), ("Maria", "prog1", 1.0), ("Maria", "prog2", 1.3), ("Maria", "prog3", 1.7), ("Hans", "prog2", 1.7), ("Josef", "prog1", 1.3), ("Maria", "mathe1", 1.3), ("Josef", "db", 3.3), ("Hans", "prog1", 2.0))

然后,每个学生应该绘制他们的课程和成绩列表.使用foldLeft,就像这样:

grades.foldLeft(Map[String, List[(String, Double)]]())((acc, e) => acc + (e._1 -> (acc.getOrElse(e._1, List()) ::: List((e._2, e._3))))).toList

输出:

List[(String, List[(String, Double)])] = List((Hans,List((db,2.3), (prog2,1.7), (prog1,2.0))), (Maria,List((prog1,1.0), (prog2,1.3), (prog3,1.7), (mathe1,1.3))), (Josef,List((prog1,1.3), (db,3.3))))

如何仅使用map和filter函数实现相同的输出？到目前为止我有这个,但输出略有不同.

grades.map(x => (x._1, List())).distinct.flatMap(x => grades.map(z => if(!x._2.contains(z._2, z._3)) (x._1, x._2 ::: List((z._2, z._3)))))

根据我的理解，Haskell 使用惰性求值，它允许在有限的时间内对例如无限列表的操作进行求值。

作为测试，我定义了以下函数

X Boolean
Y Int

f(X,Y) = (Y == 3) OR X

因此， fold left 应用于[1..]具有False初始值的无限整数列表和上面定义的函数，应该返回True，因为当它达到n=3评估时f(n==3,False)将返回True，因此这True将通过函数传播。

我在 Haskell 代码中实现了这个功能

myfunc :: Bool -> Int -> Bool
myfunc True _ = True
myfunc _ n
  | (n == 3)  = True
  | otherwise = False

并在 cli 中试用

foldl myfunc False [1..]

该命令变得无响应，表明它正在执行无限计算。为什么 Haskell 没有从这里的惰性求值中受益？