F#元组排序数组 let标准=（0,4.5M,4L） 设元组=[|（（“A”，-2,1.0M，2L）； （“B”、-1、2.0M、3L）； （“C”、0、3.0米、4升）； （“D”、1、4.0米、5升）； | 设限定=元组 |>数组.sortBy（fun（u，a，b，c）->（a，-b，c）） |>filter（fun（，a，b，c）->（a，b，c）=0，第三个元素=4L 但是我的代码不起作用！ 让我知道如何写一个函数可以做这个工作！ 谢谢，祝你周末愉快。 John

只需更改以下内容的最后一行：

let standard = (0, 4.5M, 4L)
let tuples = [| ("A", -2, 1.0M, 2L); 
                ("B", -1, 2.0M, 3L); 
                ("C", 0, 3.0M, 4L); 
                ("D", 1, 4.0M, 5L); 
                ("E", 2, 5.0M, 6L) |]
let qualified = tuples
              |> Array.sortBy(fun (_, a, b, c) -> (a, -b, c))
              |> Array.filter(fun (_, a, b, c) -> (a, b, c) <= standard)
printfn "%A" qualified

Array.filter（fun（u，a，b，c）->let（x，y，z）=a>=x&&b=z中的标准值）

请注意，元组（“D”，1，4.0M，5L）也适用

更新：

托马斯是对的，最好先过滤。 解决这个问题的另一个有趣的函数方法是使3-uple成为一个可应用的函子

Array.filter(fun (_, a, b, c) -> let (x,y,z) = standard in a >= x && b <= y && c >= z)

让纯'x=（x，x，x）
设（）（f，g，h）（x，y，z）=（fx，gy，hz）
让标准=（0,4.5米，4升）
设元组=[|（（“A”，-2,1.0M，2L）；
（“B”、-1、2.0M、3L）；
（“C”、0、3.0米、4升）；
（“D”、1、4.0米、5升）；
|
设限定=元组
|>数组.filter（fun（，a，b，c）->（（>=），（=）（a，b，c）标准=纯“真”
|>数组.sortBy（fun（u，a，b，c）->（a，-b，c））

只需更改以下内容的最后一行：

let standard = (0, 4.5M, 4L)
let tuples = [| ("A", -2, 1.0M, 2L); 
                ("B", -1, 2.0M, 3L); 
                ("C", 0, 3.0M, 4L); 
                ("D", 1, 4.0M, 5L); 
                ("E", 2, 5.0M, 6L) |]
let qualified = tuples
              |> Array.sortBy(fun (_, a, b, c) -> (a, -b, c))
              |> Array.filter(fun (_, a, b, c) -> (a, b, c) <= standard)
printfn "%A" qualified

Array.filter（fun（u，a，b，c）->let（x，y，z）=a>=x&&b=z中的标准值）

请注意，元组（“D”，1，4.0M，5L）也适用

更新：

托马斯是对的，最好先过滤。 解决这个问题的另一个有趣的函数方法是使3-uple成为一个可应用的函子

Array.filter(fun (_, a, b, c) -> let (x,y,z) = standard in a >= x && b <= y && c >= z)

让纯'x=（x，x，x）
设（）（f，g，h）（x，y，z）=（fx，gy，hz）
让标准=（0,4.5米，4升）
设元组=[|（（“A”，-2,1.0M，2L）；
（“B”、-1、2.0M、3L）；
（“C”、0、3.0米、4升）；
（“D”、1、4.0米、5升）；
|
设限定=元组
|>数组.filter（fun（，a，b，c）->（（>=），（=）（a，b，c）标准=纯“真”
|>数组.sortBy（fun（u，a，b，c）->（a，-b，c））

我不认为有任何聪明的方法可以使用在元组上工作的内置比较来完成您需要的工作。主要问题是比较将第一个元素视为最重要的元素，因此它决定只使用前几个元素（甚至不考虑其余的值。您的条件指定了对所有元素的限制。因此，Gustavo的解决方案可能是最简单的方法

但是，还有一些小问题-首先，在排序之前执行过滤可能是一个好主意，因为这样您的排序函数将需要对较少的元素进行排序：

let pure' x = (x,x,x)
let (<*>) (f,g,h) (x,y,z) = (f x, g y, h z)

let standard = (0, 4.5M, 4L)
let tuples = [| ("A", -2, 1.0M, 2L); 
                ("B", -1, 2.0M, 3L); 
                ("C", 0, 3.0M, 4L); 
                ("D", 1, 4.0M, 5L); 
                ("E", 2, 5.0M, 6L) |]
let qualified = tuples              
              |> Array.filter(fun (_, a, b, c) -> ((>=),(<=),(>=)) <*> (a,b,c) <*> standard = pure' true)
              |> Array.sortBy(fun (_, a, b, c) -> (a, -b, c))

如果您想用易于更改的全局值表示条件，那么创建一个包含3个值的元组来指定所需的最小值/最大值是不够的，因为您没有说明该值是最小值还是最大值……但是，您可以使用一个指定条件的函数元组：

 let qualified = 
   tuples 
   |> Array.sortBy (...) 
   |> Array.filter (...)

---

我不认为有任何聪明的方法可以使用在元组上工作的内置比较来完成您需要的工作。主要问题是比较将第一个元素视为最重要的元素，因此它决定只使用前几个元素（甚至不考虑其余的值。您的条件指定了对所有元素的限制。因此，Gustavo的解决方案可能是最简单的方法

但是，还有一些小问题-首先，在排序之前执行过滤可能是一个好主意，因为这样您的排序函数将需要对较少的元素进行排序：

let pure' x = (x,x,x)
let (<*>) (f,g,h) (x,y,z) = (f x, g y, h z)

let standard = (0, 4.5M, 4L)
let tuples = [| ("A", -2, 1.0M, 2L); 
                ("B", -1, 2.0M, 3L); 
                ("C", 0, 3.0M, 4L); 
                ("D", 1, 4.0M, 5L); 
                ("E", 2, 5.0M, 6L) |]
let qualified = tuples              
              |> Array.filter(fun (_, a, b, c) -> ((>=),(<=),(>=)) <*> (a,b,c) <*> standard = pure' true)
              |> Array.sortBy(fun (_, a, b, c) -> (a, -b, c))

如果您想用易于更改的全局值表示条件，那么创建一个包含3个值的元组来指定所需的最小值/最大值是不够的，因为您没有说明该值是最小值还是最大值……但是，您可以使用一个指定条件的函数元组：

 let qualified = 
   tuples 
   |> Array.sortBy (...) 
   |> Array.filter (...)

---

代码以什么方式“不起作用”？代码以什么方式“不起作用”？非常感谢。但是，我在想另一种方法：如果我在元组数组的第三个元素之前使用put negative，然后对元组数组进行排序，然后简单地与标准元组进行比较，我可能会得到正确的结果，但我必须做一些测试。再次感谢您的代码！@Gustavo-使用应用程序函子是一个有趣的方法可能，但我认为这只是无缘无故地使代码过于复杂。我觉得即使是我的版本也可能不必要地复杂，但至少你不需要引入像应用函数：-）这样的花哨概念。（即，我认为F不应该盲目地采用Haskell模式）@Tomas-你可能是对的。这种情况可能太多了。我个人喜欢applicative functor的可读性，并想展示另一种选择。非常感谢。但是，我在想另一种方法：如果我在元组数组的第三个元素之前使用put-negative，那么对元组数组进行排序，然后简单地与标准元组，我可能会得到正确的结果，但我必须做一些测试。再次感谢您的代码！@Gustavo-使用应用程序函子是一种有趣的可能性，但我认为这只是毫无理由地使代码过于复杂。我觉得即使是我的版本也可能不必要地复杂，但至少您不需要介绍引入一些奇特的概念，比如应用函子：-）（也就是说，我认为F#不应该盲目地采用Haskell模式）@Tomas-你可能是对的。对于这种情况，可能太多了。我个人喜欢applicative functor的可读性，并想展示另一种选择。你好，Tomas：非常感谢你的优秀代码和详细解释。代码中还有一个小问题，最好先过滤再排序！再次感谢你约翰·哈罗，托马斯：非常感谢