Question

我有一个(string * int) list元素列表，我需要找到最大的int元素并返回相应的(string * int)元素。

我有类似atm的东西，但是问题是，我认为我的方法更多是“典型编程”

let it = [] in
for x = 0 to length LIST - 1 do
let str = ((List.nth LIST x).string) in
let num = ((List.nth LIST x).int) in
let it = it @ [num, str] in 
let (str, num) = List.hd(List.rev it) in
[str, num]

我想做的是循环遍历列表，并将字符串和int值添加到另一个列表中，然后对其进行排序，反转然后取头（应该是最大int），然后我需要返回在(string * int)

中配对

Answer 1

您的代码不是格式正确的OCaml代码。但是，它突出显示了您对OCaml的一些理解问题。

首先，默认情况下，OCaml中的值是不可变。例如，

  let x = 0 in
  for i = 0 to 10 do
    let x = x + 1 in
    print_int x;
  done

您将获得11111111111作为输出。这是因为，在循环期间，每次x+1表达式时您都在计算，其中x始终为0，并且您将始终得到1作为结果。这是因为let x = <expr> in <body>不会更改现有变量x，而是会创建一个新变量x（遮盖以前的所有定义），并使其在{{1}的范围内可用}表达式。

一般来说，应该将其作为递归函数<body>来解决，该函数具有以下定义，

对于空列表greatest_element，它是未定义的；
对于一个元素[]的列表是[x];
否则，对于x的列表是x::xs

其中max x (greatest_element xs),为max x y，如果它大于或等于x。

最后，您似乎错过了OCaml的第一步，并且在解决此任务之前，您必须先回过头来学习基础知识。特别是，您必须学习如何调用函数，绑定变量，以及通常该语言的词汇约定和语法是什么。如果您需要指示器，请随时询问。

Answer 2

首先，似乎您没有进行任何排序您提供的代码。
假设您的列表是类型 (string * int) list，然后可以使用使用递归的最大整数：

let max_in_list list =
    let rec auxiliary max_str max_int = function
    | [] 
        -> (max_str, max_int)
    | (crt_str, crt_int)::tail when crt_int > max_int 
        -> auxiliary crt_str crt_int tail
    | _::tail 
        -> auxiliary max_str max_int tail
    in
    match list with
    | [] 
        -> None
    | (fst_str, fst_int)::tail 
        -> Some (auxiliary fst_str fst_int tail)

let check = max_in_list [("some", 1); ("string", 3); ("values", 2)]

Answer 3

您可以编写一个通用的maxBy函数。这使您可以获得 any 列表的最大值-

let rec maxBy f = function
  | [] -> None
  | [ x ] -> Some x
  | x :: xs ->
      match (maxBy f xs) with
        | Some y when (f y) > (f x) -> Some y
        | _ -> Some x
(* val maxBy : ('a -> 'b) -> 'a list -> 'a option = <fun> *)

let data = [("a", 3); ("b", 2); ("c", 6); ("d", 1)]
(* val data : (string * int) list = [("a", 3); ("b", 2); ("c", 6); ("d", 1)]*)

maxBy (fun (_, num) -> num) data
(* - : (string * int) option = Some ("c", 6) *)

maxBy (fun (str, _) -> str) data
(* - : (string * int) option = Some ("d", 1) *)

maxBy (fun x -> x) [3; 2; 6; 1]
(* - : int option = Some 6 *)

maxBy (fun x -> x) ["c"; "d"; "b"; "a"]
(* - : string option = Some "d" *)

maxBy (fun x -> x) []
(* - : 'a option = None *)

以各种方式重写同一功能可能很有趣。这是另一种编码-

let maxBy f list =
  let rec loop r = function
    | [] -> r
    | x::xs when (f x) > (f r) -> loop x xs
    | _::xs -> loop r xs
  in
  match list with
    | [] -> None
    | x::xs -> Some (loop x xs)
(* val maxBy : ('a -> 'b) -> 'a list -> 'a option = <fun> *)

在（（string * int）list）列表中查找最大值

3 个答案: