Scala: come posso ordinare una matrice di tuple dal loro secondo elemento?

Question

C'è un modo in Scala per ordinare una serie di tuple usando una funzione di confronto arbitrario? In particolare, ho bisogno di ordinare e array di tuple dal loro secondo elemento, ma volevo sapere una tecnica generale per ordinare array di tuple.

Grazie!

Answer 1

È possibile utilizzare questo codice:

scala> val v = Array(('a', 2), ('b', 1)) 
v: Array[(Char, Int)] = Array((a,2), (b,1)) 

scala> scala.util.Sorting.stableSort(v, 
    | (e1: (Char, Int), e2: (Char, Int)) => e1._2 < e2._2) 

scala> v 
res11: Array[(Char, Int)] = Array((b,1), (a,2)) 

Unfortunetly, sembra che alla Scala non può dedurre il tipo di matrice passata a stableSort. Spero che sia ok per te.

Answer 2

Probabilmente si desidera def stableSort[K](a : Seq[K], f : (K, K) => Boolean) : Array[K] da scala.util.Sorting.
La tua funzione di confronto sarebbe qualcosa come _._2 < _._1

Answer 3

In scala 2.8, c'è un metodo sortBy. Ecco un semplice caso d'uso:

Welcome to Scala version 2.8.0.r21376-b20100408020204 (Java HotSpot(TM) Client VM, Java 1.6.0_18). 
Type in expressions to have them evaluated. 
Type :help for more information. 

scala> val arr = Array(("One",1),("Two",2),("Four",4),("Three",3)) 
arr: Array[(java.lang.String, Int)] = Array((One,1), (Two,2), (Four,4), (Three,3)) 

scala> arr.sortBy(_._2) 
res0: Array[(java.lang.String, Int)] = Array((One,1), (Two,2), (Three,3), (Four,4)) 

scala> 

Answer 4

val l = List((2, 1), (3, 2), (0, 3)) 
l sort { case(a, b) => a > b } 

Answer 5

Su Scala 2.8 (sì, ancora una volta :), si può anche fare questo:

val v = Array(('a', 2), ('b', 1)) 
scala.util.Sorting.stableSort(v)(manifest[(Char, Int)], Ordering.by(_._2)) 

Nel caso specifico di coppie, anche questo può lavorare per ordinare prima dal secondo elemento, e quindi dal primo:

scala.util.Sorting.stableSort(v)(manifest[(Char, Int)], Ordering.by(_.swap)) 

Answer 6

2,7 e non in luogo:

(Array((2,3), (4,2), (1,5)).toList.sort (_._2 < _._2)).toArray 

Answer 7

Se è un Array, probabilmente è tipico da utilizzare sul posto algoritmi di ordinamento. Tuttavia, nel codice Scala idiomatico, le raccolte mutabili di solito non sono incoraggiate/utilizzate. Se questo è il caso e si dispone del mattino raccolta immutabili (o vorrebbe non modificare il Array sul posto), utilizzare sortWith:

scala> val a = Array(1, 3, 2, 5) 
a: Array[Int] = Array(1, 3, 2, 5) 

scala> a.sortWith(_ > _) 
res6: Array[Int] = Array(5, 3, 2, 1) 

scala> a 
res7: Array[Int] = Array(1, 3, 2, 5) 

ordinamento di un Array o qualsiasi altra raccolta di tuple:

scala> val a = Array(('a', 1), ('b', 4), ('c', 5), ('d', 2)) 
a: Array[(Char, Int)] = Array((a,1), (b,4), (c,5), (d,2)) 

scala> a.sortWith(_._2 > _._2) 
res4: Array[(Char, Int)] = Array((c,5), (b,4), (d,2), (a,1)) 

scala> a 
res5: Array[(Char, Int)] = Array((a,1), (b,4), (c,5), (d,2))