在scala中结合两个列表

我是scala的新手，有可能是一个非常简单的问题。我有List（（Int，String））形式的两个列表，并且想要组合字符串相同的整数。例如：在scala中结合两个列表

l1 = List((1,"a"),(3,"b")) 
l2 = List((3,"a"),(4,"c"))

我想这些组合成第三列表，像这样：

l3 = List((4,"a"),(3,"b"),(4,"c"))

现在，我穿越两个列表和添加如果字符串是相同的，但我认为应该有一个模式匹配的简单解决方案。任何帮助表示赞赏。

来源

2011-10-01 Samuel Thomas

类似的问题：http://stackoverflow.com/questions/7076128/best-way- to-merge-two-maps-and-sum-the-values-of-same-key – Infinity

只是我，还是这个问题似乎更容易解决，当你有List [（String，Int）]而不是List [ （Int，String）]？ –

val l = l1 ::: l2 
val m = Map[String, Int]() 
(m /: l) { 
    case (map, (i, s)) => { map.updated(s, i + (map.get(s) getOrElse 0))} 
}.toList // Note: Tuples are reversed.

但我想有一个更优雅的方式来做updated部分。

来源

2011-10-01 17:38:43 Debilski

感谢您的支持。这正是我要找的。如果可以的话，我会投你一票。 –

请注意，通过此解决方案，列表遍历两次。

val l3 = (l1 zip l2).foldRight(List[(Int, String)]()) { 
    case ((firstPair @ (firstNumber, firstWord), 
     secondPair @ (secondNumber, secondWord)), 
     result) => 
    if (firstWord == secondWord) 
     ((firstNumber + secondNumber), firstWord) :: result 
    else 
     firstPair :: secondPair :: result 
}

来源

2011-10-01 18:02:13 agilesteel

怎么样，

(l1 ++ l2).groupBy(_._2).mapValues(_.unzip._1.sum).toList.map(_.swap)

拆开这一点上REPL有助于证明这是怎么回事，

scala> l1 ++ l2 
res0: List[(Int, java.lang.String)] = List((1,a), (3,b), (3,a), (4,c)) 

scala> res0.groupBy(_._2) 
res1: ... = Map(c -> List((4,c)), a -> List((1,a), (3,a)), b -> List((3,b))) 

scala> res1.mapValues(_.unzip) 
res2: ... = Map(c -> (List(4),List(c)), a -> (List(1, 3),List(a, a)), b -> (List(3),List(b)))       

scala> res1.mapValues(_.unzip._1)                                          
res3: ... = Map(c -> List(4), a -> List(1, 3), b -> List(3))                      

scala> res1.mapValues(_.unzip._1.sum) 
res4: ... = Map(c -> 4, a -> 4, b -> 3)                            

scala> res4.toList                                              
res5: List[(java.lang.String, Int)] = List((c,4), (a,4), (b,3))                                   

scala> res5.map(_.swap) 
res6: List[(Int, java.lang.String)] = List((4,c), (4,a), (3,b))

来源

2011-10-01 18:21:38

虽然每次我可以在不使用换行符的情况下实现一个函数时，我倾向于给自己一个轻拍，但这非常不透明！你能否给一些中间产品提供一些名称，使其明显是正确的？ –

我建议从REPL开始到结束每个中间结果，从（l1 ++ l2）开始，然后（l1 ++ l2）.groupBy（_._ 2）...等等。 –

我曾经 - 但我很感兴趣 - 你真的会在源代码中留下一行代码吗，还是将它与解释变量名分开？ –

随着Scalaz，这是一个单元。

import scalaz._ 
import Scalaz._ 

val l3 = (l1.map(_.swap).toMap |+| l2.map(_.swap).toMap) toList

的|+|方法被暴露在所有类型T存在用于其的Semigroup[T]的实现。而恰恰是这样，Map[String, Int]的半群正是你想要的。

来源

2011-10-01 21:18:08 Apocalisp

另一个不透明一个两衬垫可疑效率但不容置疑的功效：

val lst = l1 ++ l2 
lst.map(_._2).distinct.map(i => (lst.filter(_._2 == i).map(_._1).sum, i))

来源

2011-10-02 00:18:55

for ((k,v) <- (l1++l2).groupBy(_._2).toList) yield (v.map(_._1).sum, k)

来源

2012-01-06 08:43:34 AmigoNico

val a = List(1,1,1,0,0,2) 
val b = List(1,0,3,2) 

scala> List.concat(a,b) 
res31: List[Int] = List(1, 1, 1, 0, 0, 2, 1, 0, 3, 2) 

(or) 

scala> a.:::(b) 
res32: List[Int] = List(1, 0, 3, 2, 1, 1, 1, 0, 0, 2) 

(or) 

scala> a ::: b 
res28: List[Int] = List(1, 1, 1, 0, 0, 2, 1, 0, 3, 2)

来源

2017-04-16 15:13:50

在scala中结合两个列表

回答

相关问题