F # Seq.sortBy w porządku malejącym

Question

Jestem całkiem nowy dla F # i przyszedł przez funkcję Seq.sortBy jednak sortuje moją listę w porządku rosnącym. Jak mogę go posortować w porządku malejącym, używając Seq.sort?

Na przykład kod Przykładem może być ...

let DisplayList = 
seq{0..10} 
|> Seq.sortBy(fun x -> x) 
|> Seq.iter(fun x -> Console.WriteLine(x.ToString())) 

daje mi moc 1 2 3 4 5 6 7 8 9 10, kiedy naprawdę chcesz to zrobić to od 10 do 1.

Answer 1

Patrząc na inne odpowiedzi, uważaj jednoargumentowy minus i MinInt:

let a = [| 1; -1; System.Int32.MinValue; 0; System.Int32.MaxValue; 1 |] 

printfn "%A" (a |> Array.sortBy (fun x -> x)) 
// [|-2147483648; -1; 0; 1; 1; 2147483647|] 

printfn "%A" (a |> Array.sortBy (fun x -> -x)) // uh-oh! 
// [|-2147483648; 2147483647; 1; 1; 0; -1|] 

Chyba rzeczywiście chcesz negatywny-X-minus jeden :

printfn "%A" (a |> Array.sortBy (fun x -> -x - 1)) 
// [|2147483647; 1; 1; 0; -1; -2147483648|] 

za zawinięcie około typu integer, który obejmuje -2^N..2^N-1.

Answer 2

można rozwiązać ten problem poprzez dostarczenie negatywnego klucza

let DisplayList = 
    seq { 0..10 } 
    |> Seq.sortBy (fun x -> -x) 
    |> Seq.iter (fun x -> Console.WriteLine(x.ToString())) 

również jest nieco łatwiej (i wpisać bezpieczniejszy), aby korzystać z funkcji printf do wyświetlania tekstu w F #. Na przykład

let DisplayList = 
    seq { 0..10 } 
    |> Seq.sortBy (fun x -> -x) 
    |> Seq.iter (printfn "%d") 

Answer 3

jeszcze krócej:

seq { 0..10 } 
    |> Seq.sortBy (~-) // Unary minus 
    |> Seq.iter (printfn "%d") 

Answer 4

Jeśli wiesz, z wyprzedzeniem, że będziesz mieć stosunkowo małą sekwencję, myślę, że jest to bardziej czytelne ...

let x = seq { 0.. 10 } |> Seq.toArray |> Array.rev

Oczywiście, nie jest wskazane, jeśli masz potencjalnie bardzo duża sekwencja.

Answer 5

Najpierw rozszerzmy Seq o funkcję sortWith, taką samą jak lista i macierz.

namespace Microsoft.FSharp.Collections 
module Seq = 
    let sortWith f e = 
     let e' = e |> Seq.toArray 
     e' |> Array.sortInPlaceWith f 
     e' |> Seq.readonly 

Następnie niech przedłużyć Operators z często przydatnych flip funkcji.

namespace Microsoft.FSharp.Core 
module Operators = 
    let flip f x y = f y x 

Teraz możemy wykorzystać funkcję rodzajowe compare generic (można użyć dowolnej kolejności to z porównywalnych elementów) i sejf (w odniesieniu do obserwacji Briana) odwrotna kolejność sortowania.

{0..10} 
|> Seq.sortWith (flip compare) 
|> Seq.iter (printfn "%A") 

Answer 6

Inną opcją jest owinąć System.Linq.Enumerable.OrderByDescending():

// #r "System.Core" 
module Seq = 
    let sortByDesc f s = Enumerable.OrderByDescending(s, new Func<'a, 'b>(f)) 

{0..10} |> Seq.sortByDesc (fun x -> x) 

Answer 7

rozwiązania wykorzystujące jednoargumentowy minus: (fun x -> -x - 1) i (fun x -> -x) nie działają, gdy masz niepodpisanych typy:

let a = [| 0uy; 255uy; 254uy; 1uy |] 
printfn "%A" (a |> Array.sortBy (fun x -> -x - 1)) 
// error FS0001: The type 'byte' does not support the operator '~-' 

Zamiast możemy użyć faktu, że -x = ~~~x + 1 gdzie ~~~ jest ab operator negacji itwise i tym samym -x - 1 = ~~~x.Tak krótki rozwiązanie, które działa zarówno podpisanych i niepodpisanych typów:

Array.sortBy (~~~) // equivalent to Array.sortBy (fun x -> ~~~x) 

Przykłady:

let a = [| 0uy; 255uy; 254uy; 1uy |] 
printfn "%A" (a |> Array.sortBy (~~~)) 
// [|255uy; 254uy; 1uy; 0uy|] 
let a = [| 1; -1; System.Int32.MinValue; 0; System.Int32.MaxValue; 1 |] 
printfn "%A" (a |> Array.sortBy (~~~)) 
// [|2147483647; 1; 1; 0; -1; -2147483648|] 

Answer 8

F # 4.0 (Visual Studio 2015) wprowadziła Seq.sortByDescending i Seq.sortDescending

let DisplayList = 
    seq { 0..10 } 
    |> Seq.sortDescending   ' or |> Seq.sortByDescending id 
    |> Seq.iter Console.WriteLine 

Zobacz https://github.com/Microsoft/visualfsharp/wiki/F%23-4.0-Status i https://github.com/fsharp/FSharpLangDesign/blob/master/FSharp-4.0/ListSeqArrayAdditions.md