Wie kann ich diese Liste sortieren?

Question

Ich habe eine Liste von Listen.

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;
}

Jetzt möchte ich sortieren li und zwar so, dass der höhere foo(x) für eine x höher sollte sie in einer sortierten Liste erscheinen.

Was ist der beste Weg in C#/Python/jede andere lang zu diesem?

Answer 1

Mit ein bisschen LINQ:

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

Answer 2

Die Haskell-Lösung ist besonders elegant mit dem on Kombinator aus Data.Function.

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

Ausgabe:

\[\[1,2,3\],\[5,6,8\]\]

Außerdem gibt es comparing aus Data.Ord, die uns stattdessen schreiben lässt

main = do
  print $ sortBy (comparing foo) lists
  where
    foo = sum

En Definition von comparing ist eine unkomplizierte

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

aber wir könnten es auch in Form von on :

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

oder völlig punktfrei mit

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

Haskell manipuliert Funktionen so mächtig wie Perl Zeichenketten manipuliert.

Answer 3

Dies ist der Python-Weg: Übergeben Sie einfach die Funktion als key Argument zu sorted() o .sort() :

>>> mylist = [123, 765, 4, 13]
>>> def mod5(x):
...     return x%5
...
>>> sorted(mylist, key = mod5)
[765, 123, 13, 4]
>>> sorted(mylist, key = mod5, reverse = True)
[4, 123, 13, 765]

Answer 4

Rubin:

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}}

Ich bin mir der Regeln von Code Golf nicht sicher, und ich habe keine foo-Methode geschrieben, aber die Summe könnte leicht in foo auftreten.

Meine Testausgabe:

puts sortedlist.inspect

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

Answer 5

In Perl wird dies oft mit dem bekannten Schwartzsche Transformation .

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

Wiederverwendung Sortieren::Schlüssel ist jedoch besser.

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