blocks|key|1177326|text|再加上一点LINQ：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1177327|var+q+=+from+el+in+li
++++++++orderby+foo(el)
++++++++select+el;
li+=+q.ToList();|code-block|syntax|javascript|1177328|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

With a little bit of LINQ:

<pre><code>var q = from el in li
 orderby foo(el)
 select el;
li = q.ToList();
</code></pre>

blocks|key|2819726|text|这是Python的方式:只需将函数作为key参数传递给sorted()或.sort()|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2819727|>>>+mylist+=+[123,+765,+4,+13]
>>>+def+mod5(x):
...+++++return+x%255
...
>>>+sorted(mylist,+key+=+mod5)
[765,+123,+13,+4]
>>>+sorted(mylist,+key+=+mod5,+reverse+=+True)
[4,+123,+13,+765]|code-block|syntax|javascript|2819728|entityMap^0|J|3|R|8|10|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

This is the Python way: Just pass the function as the <code>key</code> argument to <code>sorted()</code> or <code>.sort()</code>:

<pre><code>&gt;&gt;&gt; mylist = [123, 765, 4, 13]
&gt;&gt;&gt; def mod5(x):
... return x%5
...
&gt;&gt;&gt; sorted(mylist, key = mod5)
[765, 123, 13, 4]
&gt;&gt;&gt; sorted(mylist, key = mod5, reverse = True)
[4, 123, 13, 765]
</code></pre>

blocks|key|1178277|text|红宝石：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1178278|mylist+=+[[1,2,3],
+++++++++++++[3,5,9],
+++++++++++++[1,1,1],
+++++++++++++[10,23,14]]

sortedlist+=+mylist.sort+{%7Ca,b%7C+b.inject+{%7Csum,+n%7C+sum+%2B+n+}+<=>+a.inject+{%7Csum,n%7C+sum+%2B+n}}|code-block|syntax|javascript|1178279|我不确定Code的规则和我没有编写foo方法，但是在foo中可以很容易地得到和。|1178280|我的测试输出：|1178281|puts+sortedlist.inspect|1178282|[10、23、14、3、5、9、1、2、3、1、1、1、1]|1178283|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Ruby:

<pre><code>mylist = [[1,2,3],
 [3,5,9],
 [1,1,1],
 [10,23,14]]

sortedlist = mylist.sort {|a,b| b.inject {|sum, n| sum + n } &lt;=&gt; a.inject {|sum,n| sum + n}}
</code></pre>

I'm not sure the rules of Code Golf and I didn't write a foo method, but the sum could easily occur in foo.

My test output:

<pre><code>puts sortedlist.inspect
</code></pre>

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

blocks|key|2819876|text|在Perl中，这通常是通过众所周知的Schwartzian变换来完成的.|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2819877|use+List::Util+qw(sum);
@li+=+map+{$$_[0]}+sort+{$$a[1]+<=>+$$b[1]}+map+{[$_,+sum(@$_)]}+@li;|code-block|syntax|javascript|2819878|不过，重用类别：：Key更好。|2819879|use+List::Util+qw(sum);
use+Sort::Key+qw(nkeysort);
@li+=+nkeysort+{sum(@$_)}+@li;|2819880|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Schwartzian_transform|1|http://search.cpan.org/perldoc?Sort::Key^0|I|D|0|0|0|5|7|1|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|K|3|L|5|F|7|15|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

In Perl, this is often done with the well-known <a href="http://en.wikipedia.org/wiki/Schwartzian_transform" rel="nofollow noreferrer">Schwartzian transform</a>.

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

Reusing <a href="http://search.cpan.org/perldoc?Sort::Key" rel="nofollow noreferrer">Sort::Key</a> is better, though.

<pre><code>use List::Util qw(sum);
use Sort::Key qw(nkeysort);
@li = nkeysort {sum(@$_)} @li;
</code></pre>

blocks|key|1177337|text|还有其他语言吗？好的，下面是一些F#：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1177338|示例:按总和排序：|1177339|let+foo+=+List.sum
let+li+=+[[1;2];[42;1];[3;4]]

let+result+=+li+%7C>+List.sortBy+(fun+el+->+foo+el)|code-block|syntax|javascript|1177340|结果(F#互动)：|1177341|val+result+:+int+list+list+=+[[1;+2];+[3;+4];+[42;+1]]|1177342|高尔夫球：|1177343|let+result+=+li+%7C>+List.sortBy+(fun+el+->+foo+el)
//shorter
let+res+=+li+%7C>+List.sortBy+foo
//evn+shrtr
let+r=List.sortBy+foo+li|1177344|C#版本：|1177345|var+result+=+li.OrderBy(el=>el.Sum());|1177346|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Any other language? Ok, here's some F#:

Example: sort by sum:

<pre><code>let foo = List.sum
let li = [[1;2];[42;1];[3;4]]

let result = li |&gt; List.sortBy (fun el -&gt; foo el)
</code></pre>

Result (F# interactive):

<pre><code>val result : int list list = [[1; 2]; [3; 4]; [42; 1]]
</code></pre>

Golfed:

<pre><code>let result = li |&gt; List.sortBy (fun el -&gt; foo el)
//shorter
let res = li |&gt; List.sortBy foo
//evn shrtr
let r=List.sortBy foo li
</code></pre>

The C# version:

<pre><code>var result = li.OrderBy(el=&gt;el.Sum());
</code></pre>

blocks|key|1296689|text|在erlang：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1296690|-module+(codegolfs).
-export+([sortmain/0]).

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

sort(Fun,List)+->
++++lists:sort(+fun(A,B)+->+Fun(A)+<+Fun(B)+end,List+).|code-block|syntax|javascript|1296691|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

in erlang:

<pre><code>-module (codegolfs).
-export ([sortmain/0]).

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

sort(Fun,List) -&gt;
 lists:sort( fun(A,B) -&gt; Fun(A) &lt; Fun(B) end,List ).
</code></pre>

blocks|key|1177437|text|Ruby+(无耻地复制Beanish的输入数据)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1177438|list+=+[
++[1,+2,+3],
++[3,+5,+9],
++[1,+1,+1],
++[10,+23,+14]
]

p+list.sort_by+{+%7Ca%7C+-a.inject(&:%2B)+}
#+=>+[[10,+23,+14],+[3,+5,+9],+[1,+2,+3],+[1,+1,+1]]|code-block|syntax|javascript|1177439|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Ruby (shamelessly copying Beanish's input data):

<pre><code>list = [
 [1, 2, 3],
 [3, 5, 9],
 [1, 1, 1],
 [10, 23, 14]
]

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

blocks|key|1296814|text|克洛尔：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1296815|(let+[lst+'((1+2+3)++(3+5+9)+(1+1+1)+(10+23+14))]+++
+(sort+#(>+(foo+%251)+(foo+%252))+lst))|code-block|syntax|javascript|1296816|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Clojure:

<pre><code>(let [lst '((1 2 3) (3 5 9) (1 1 1) (10 23 14))] 
 (sort #(&gt; (foo %1) (foo %2)) lst))
</code></pre>

blocks|key|1296650|text|您可以调整任何流行的排序例程来完成此操作。只需使用foo(+x+)进行比较，而不是使用x。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1296651|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You could adapt any of the popular sorting routines to do this. Just use foo(x) for comparison rather than x.

blocks|key|2819895|text|Tcl：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2819896|proc+foo+nums+{tcl::mathop::%2B+{*}$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}|code-block|syntax|javascript|2819897|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Tcl: 

<pre><code>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
# =&gt; {42 -40} 3 {1 2 3} {4 5 6}
</code></pre>

I have a list of lists.

<pre><code>List&lt;List&lt;T&gt;&gt; li = {
 {a1,a2,a3 ... aN},
 {b1,b2,b3 ... bN},
 ...
};

double foo(List&lt;T&gt; list)
{
 // do something 
 // e.g {1,2,3} 
 // it = 1 + 2 + 3

 return it;
}
</code></pre>

Now I want to sort <code>li</code> in such a way that higher the <code>foo(x)</code> for a <code>x</code> higher it should appear in a sorted list.

What is the best way in C#/Python/any other lang to this?

How do I sort this list?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我有一份名单。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进行排序，使foo(x)越高，

问我该怎么整理这张单子？
EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我该怎么整理这张单子？EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我该怎么整理这张单子？
EN