C# 如何对该列表进行排序？

我有一份清单

List<List<T>> li = {
   {a1,a2,a3 ... aN},
   {b1,b2,b3 ... bN},
   ...
};

double foo(List<T> list)
{
    // do something 
    // e.g {1,2,3} 
    // it = 1 + 2 + 3

    return it;
}

列表li={
{a1，a2，a3…aN}，
{b1，b2，b3…bN}，
...
};
双foo（列表）
{
//做点什么
//例如{1,2,3}
//它=1+2+3
归还它；
}

现在我想对

li

进行排序，以便

foo（x）

越高的

x

应该出现在排序列表中

---

在C#/Python/任何其他语言中，实现这一点的最佳方法是什么？

您可以调整任何流行的排序例程来实现这一点。只需使用foo（x）进行比较，而不是使用x

加上一点LINQ：

var q = from el in li
        orderby foo(el)
        select el;
li = q.ToList();

---

这是Python的方法：只需将函数作为

键

参数传递给

sorted（）

或

.sort（）

：

---

Haskell解决方案使用Data.Function中的combinator特别优雅

import Data.Function (on)
import Data.List (sortBy)

lists = [ [ 5, 6, 8 ]
        , [ 1, 2, 3 ]
        ]

main = do
  print $ sortBy (compare `on` foo) lists
  where
    foo = sum

输出：

[[1,2,3],[5,6,8]] 这是一个直截了当的问题

comparing :: (Ord a) => (b -> a) -> b -> b -> Ordering
comparing p x y = compare (p x) (p y)

但我们也可以用上的

来定义它：

comparing :: (Ord b) => (a -> b) -> a -> a -> Ordering
comparing f = compare `on` f

或者完全自由点

comparing :: (Ord b) => (a -> b) -> a -> a -> Ordering
comparing = (compare `on`)

Haskell处理函数的能力和Perl处理字符串的能力一样强大。
还有其他语言吗？好的，这里有一些F#：

示例：按总和排序：

let foo = List.sum
let li = [[1;2];[42;1];[3;4]]

let result = li |> List.sortBy (fun el -> foo el)

结果（F#交互式）：

高尔菲德：

let result = li |> List.sortBy (fun el -> foo el)
//shorter
let res = li |> List.sortBy foo
//evn shrtr
let r=List.sortBy foo li

C版本：

在erlang中：

-module (codegolfs).
-export ([sortmain/0]).

sortmain() ->
    sort( 
    fun (SubList) -> lists:sum(SubList) end,
    [ [1,2,3],[1,3],[2,5,6] ]).
    % output: [[2,5,6],[1,2,3],[1,3]]

sort(Fun,List) ->
    lists:sort( fun(A,B) -> Fun(A) < Fun(B) end,List ).

-模块（codegolfs）。
-导出（[sortmain/0]）。
sortmain（）->
分类（
乐趣（子列表）->列表：总和（子列表）结束，
[ [1,2,3],[1,3],[2,5,6] ]).
%输出：[[2,5,6]，[1,2,3]，[1,3]]
排序（乐趣，列表）->
列表：排序（fun（A，B）->fun（A）
Ruby：

mylist = [[1,2,3],
             [3,5,9],
             [1,1,1],
             [10,23,14]]

sortedlist = mylist.sort {|a,b| b.inject {|sum, n| sum + n } <=> a.inject {|sum,n| sum + n}}

[[10,23,14]，[3,5,9]，[1,2,3]，[1,1,1]]
在Perl中，这通常是通过众所周知的

Tcl：

Ruby（无耻地复制Beanish的输入数据）：

Clojure：

(let [lst '((1 2 3)  (3 5 9) (1 1 1) (10 23 14))]   
 (sort #(> (foo %1) (foo %2)) lst))

我不需要排序技术。我想要一种用语言有效表达这一点的方法。为什么你要展示C#并询问Python？Python是如何进入这个问题的？@S.Lott我目前正在用C#编写代码，但我也想知道如何用Python编写代码，因为它是我最喜欢的语言！既然我的基本目的已经实现了，这也可以成为高尔夫的代码！！没关系：-）C#解决方案对你帮助最大，所以你接受了正确的解决方案。@david：我想，如果你必须给它贴上标签的话：-）@Tor Valamo:在这个例子中是这样的。但这是一个关于如何将函数用作排序键的问题，而不是关于何时使用
def
vs.
lambda
。实际用例可能比
x%5
更复杂。如何在LINQ中进行反向排序？我从这里开始：。请注意，它预装了很多样本。丹尼尔，这只是简单地标记为“代码高尔夫”。它足够短。li.OrderByDescending（elem=>foo（elem））.ToList（）你也可以通过{i | foo（i）}进行
li=li.sort_.reverse
如果性能不是什么大问题的话。当然，天真的表达式
@li=sort{sum（@$a）sum（@$b）}@li
也可以工作，为了简洁起见，交易表现。或者使用
sortWith
：我也许应该注意：
sortWith
的目的不仅仅是作为
sortBy的捷径。比较
，但实际上是为了提供通用列表理解的细节：
{-#语言转换列表comp}[list | list
var result = li.OrderBy(el=>el.Sum());

-module (codegolfs).
-export ([sortmain/0]).

sortmain() ->
    sort( 
    fun (SubList) -> lists:sum(SubList) end,
    [ [1,2,3],[1,3],[2,5,6] ]).
    % output: [[2,5,6],[1,2,3],[1,3]]

sort(Fun,List) ->
    lists:sort( fun(A,B) -> Fun(A) < Fun(B) end,List ).

mylist = [[1,2,3],
             [3,5,9],
             [1,1,1],
             [10,23,14]]

sortedlist = mylist.sort {|a,b| b.inject {|sum, n| sum + n } <=> a.inject {|sum,n| sum + n}}

puts sortedlist.inspect

use List::Util qw(sum);
@li = map {$$_[0]} sort {$$a[1] <=> $$b[1]} map {[$_, sum(@$_)]} @li;

use List::Util qw(sum);
use Sort::Key qw(nkeysort);
@li = nkeysort {sum(@$_)} @li;

proc foo nums {tcl::mathop::+ {*}$nums}
set l {{1 2 3} {4 5 6} {3} {42 -40}}
lsort -command {apply {{a b} {expr {[foo $a] - [foo $b]}}}} $l
# => {42 -40} 3 {1 2 3} {4 5 6}

list = [
  [1, 2, 3],
  [3, 5, 9],
  [1, 1, 1],
  [10, 23, 14]
]

p list.sort_by { |a| -a.inject(&:+) }
# => [[10, 23, 14], [3, 5, 9], [1, 2, 3], [1, 1, 1]]

(let [lst '((1 2 3)  (3 5 9) (1 1 1) (10 23 14))]   
 (sort #(> (foo %1) (foo %2)) lst))