序言
我想到状态可以被视为具有优先级，如果给定一系列(agent,status) 对，那么任务就是只为每个代理选择最高优先级的状态。不幸的是，status 不是强类型的，并没有使用如此定义的显式排序，但是......因为它是一个只有两个值的字符串，我们可以安全地使用字符串排序，因为它与优先级具有 1:1 的对应关系。
我的两个答案都利用了两个有用的事实：
-
在自然字符串排序中，"FAIL" < "PASS"，所以：
List("PASS", "FAIL", "PASS").sorted.head = "FAIL"
对于两个元组(x,a)和(x,b)，(x,a) > (x, b)如果(a > b)
更新回复
val solution = l.sorted.reverse.toMap
当通过.toMap 方法将Seq[(A,B)] 转换为Map[A,B] 时，原始元组序列中的每个“键”只能在生成的Map 中出现一次。碰巧的是，转换使用最后一次发生的此类事件。
l.sorted.reverse = List(
(Agent 2,PASS), // <-- Last "Agent 2"
(Agent 1,FAIL), // <-- Last "Agent 1"
(Agent,PASS),
(Agent,PASS),
(Agent,FAIL)) // <-- Last "Agent"
l.sorted.reverse.toMap = Map(
Agent 2 -> PASS,
Agent 1 -> FAIL,
Agent -> FAIL)
原始回复
从答案开始……
val oldSolution = (l groupBy (_._1)) mapValues {_.sorted.head._2}
...然后展示我的工作:)
//group
l groupBy (_._1) = Map(
Agent 2 -> List((Agent 2,PASS)),
Agent 1 -> List((Agent 1,FAIL)),
Agent -> List((Agent,PASS), (Agent,FAIL), (Agent,PASS))
)
//extract values
(l groupBy (_._1)) mapValues {_.map(_._2)} = Map(
Agent 2 -> List(PASS),
Agent 1 -> List(FAIL),
Agent -> List(PASS, FAIL, PASS))
//sort
(l groupBy (_._1)) mapValues {_.map(_._2).sorted} = Map(
Agent 2 -> List(PASS),
Agent 1 -> List(FAIL),
Agent -> List(FAIL, PASS, PASS))
//head
(l groupBy (_._1)) mapValues {_.map(_._2).sorted.head} = Map(
Agent 2 -> PASS,
Agent 1 -> FAIL,
Agent -> FAIL)
但是，您可以直接对agent -> status 对进行排序，而无需先提取_2：
//group & sort
(l groupBy (_._1)) mapValues {_.sorted} = Map(
Agent 2 -> List((Agent 2,PASS)),
Agent 1 -> List((Agent 1,FAIL)),
Agent -> List((Agent,FAIL), (Agent,PASS), (Agent,PASS)))
//extract values
(l groupBy (_._1)) mapValues {_.sorted.head._2} = Map(
Agent 2 -> PASS,
Agent 1 -> FAIL,
Agent -> FAIL)
在任何一种情况下，如果您愿意，请随时转换回对列表：
l.sorted.reverse.toMap.toList = List(
(Agent 2, PASS),
(Agent 1, FAIL),
(Agent, FAIL))