Как мне отсортировать этот список?

Question

У меня есть список списков.

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) на x он отображался в отсортированном списке.

Каков наилучший путь в C # / Python / любой другой язык к этому?

Answer 1

Решение Haskell особенно элегантно с комбинатором on от 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

Выход:

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

Существует также comparing из Data.Ord, который позволяет вместо этого писать

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

определение comparing является простым

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

но мы также можем определить его в терминах on:

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 манипулирует строками.

Answer 2

С небольшим количеством LINQ:

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

Answer 3

Это путь Python: просто передайте функцию в качестве аргумента key в sorted() или .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

В Perl это часто делается с помощью известного преобразования Шварца .

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;

Answer 5

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

Я не уверен в правилах Code Golf, и я не писал метод foo, но сумма легко может быть получена в foo.

Мой тестовый вывод:

puts sortedlist.inspect

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

Answer 6

Clojure:

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

Answer 7

Ruby (беспардонно копируя входные данные Баниша):

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

Answer 8

в эрланге:

-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 ).

Answer 9

Любой другой язык? Хорошо, вот немного F #:

Пример: сортировка по сумме:

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

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

Результат (F # интерактивный):

val result : int list list = [[1; 2]; [3; 4]; [42; 1]]

Golfed:

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 #:

var result = li.OrderBy(el=>el.Sum());

Answer 10

Tcl:

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}