查找没有重复的对的列表的并集

如何解决查找没有重复的对的列表的并集

如果两个键匹配，则具有最高值的对将添加到列表中。 例如，[("a",1);("a",4);("b",2)] U [("a",5);("b",1);("c",3)] = [("a",2);("c",3)]。

我尝试创建一个将给定对与其他列表对进行比较的函数：

`let max_val (k,v) o_lst =  if (v > (List.assoc k o_lst)) then (k,v) else (k,(List.assoc k o_lst))`

这将返回具有最大值的对，您可以假定列表在调用此函数之前按降序排序。但是，此功能的明显缺陷是，如果具有相同密钥的几对具有比其他列表更大的值，那么它们也将被添加到新列表中。

我不确定如何正确执行此操作。学习迷彩

解决方法

一种方法是将列表转换为地图，然后使用Map模块的merge函数将其加入地图：

module StrMap = Map.Make(String)

let list1 = [ "a",1; "a",4; "b",2 ]
let list2 = [ "a",5; "b",1; "c",3 ]

let map1 = List.to_seq list1 |> StrMap.of_seq
let map2 = List.to_seq list2 |> StrMap.of_seq

let max_merge =
  StrMap.merge (fun key x y ->
      match x,y with
      | Some a,None -> Some a
      | None,Some b -> Some b
      | Some a,Some b -> Some (max a b)
      | None,None -> None (* Shouldn't happen but silences a warning. *))

let map3 = max_merge map1 map2
let list3 = StrMap.bindings map3 (* [("a",5); ("b",2); ("c",3)] *)

在创建地图时，如果要添加的对列表中有重复的键，则最后一张地图将使用最后一个-因此，如果您的列表已经排序，则得到最高的键。然后将两个映射合并在一起，并且当两个映射中都存在键时，将使用最大值。

---

或者，如果您可以使用Jane Street的Base替换标准库，则它的List模块中具有许多相关的有用功能：

open Base

let list1 = [ "a",3 ]

let apply_first (a,_) (b,_) ~f = f a b

let max_merge a b =
  List.merge a b ~compare:(fun (xs,xi) (ys,yi) ->
      let cmp = String.compare xs ys in
      if cmp = 0 then Int.compare xi yi else cmp) |>
    List.remove_consecutive_duplicates ~which_to_keep:`Last
      ~equal:(apply_first ~f:String.equal)

let list3 = max_merge list1 list2 (* [("a",3)] *)

使用Core或Core_kernel可以通过Tuple模块的compare函数将其简化：

open Core

let list1 = [ "a",_) ~f = f a b

let max_merge a b =
  List.merge a b ~compare:(Tuple.T2.compare ~cmp1:String.compare ~cmp2:Int.compare) |>
    List.remove_consecutive_duplicates ~which_to_keep:`Last
      ~equal:(apply_first ~f:String.equal)

let list3 = max_merge list1 list2

最后，在很大程度上，第一个使用Base / Core Map的算法与接口的接口与Stdlib完全不同：

open Base

let list1 = [ "a",3 ]

let list_to_map = Map.of_alist_reduce (module String) ~f:max

let map1 = list_to_map list1
let map2 = list_to_map list2

let max_merge = Map.merge_skewed ~combine:(fun ~key a b -> max a b)

let map3 = max_merge map1 map2
let list3 = Map.to_alist map3

,

您的功能正在使用单对。从对的整个列表的角度来看，这可能有助于更高层次的思考。

获得期望结果的一种方法（在我看来）是附加两个列表，然后按键（作为主排序键）然后按降序值（作为辅助排序键）对结果列表进行排序。之后，您可以应用一个“ uniq”函数，该函数可抑制除每个键的第一次出现以外的所有操作。

您说您仍打算对列表进行排序。因此，唯一的新功能是“ uniq”功能。实际上，如果您正确定义比较，则可以使用List.sort_uniq。如果仍然无法解决问题，您可以编写自己的“ uniq”函数（在移动窗口中一次查看列表的两个元素）。

,

您可以将<Stepper ... style={{ width: 64*16 }}>用作累加器。

Map.Make(String)

let select_max = let module StrMap = Map.Make(String) in let rec process acc = function | ((k,v) :: t) :: src -> let acc = match StrMap.find_opt k acc with | Some vmax when vmax >= v -> acc | Some _ | None -> acc |> StrMap.remove k |> StrMap.add k v in process acc (t :: src) | [] :: src -> process acc src | [] -> StrMap.bindings acc in process StrMap.empty let test = select_max [ ["a",7; "a",9; "a",1]; ["a",1; "b",5; "c",7]; ["c",7] ]
val select_max : (String.t * int) list list -> (String.t * int) list = <fun>