Cómo en Scala para encontrar elementos únicos en la lista

Question

¿Cómo en Scala para encontrar elementos únicos en la lista?

Answer 1

La forma orden de preservación más eficaz de hacer esto sería utilizar un Set como una estructura de datos auxiliares:

def unique[A](ls: List[A]) = { 
    def loop(set: Set[A], ls: List[A]): List[A] = ls match { 
    case hd :: tail if set contains hd => loop(set, tail) 
    case hd :: tail => hd :: loop(set + hd, tail) 
    case Nil => Nil 
    } 

    loop(Set(), ls) 
} 

Nosotros Puede envolver esto en una sintaxis más agradable utilizando una conversión implícita:

implicit def listToSyntax[A](ls: List[A]) = new { 
    def unique = unique(ls) 
} 

List(1, 1, 2, 3, 4, 5, 4).unique // => List(1, 2, 3, 4, 5) 

Answer 2

Si se refiere a la Rosetta Code: Create a Sequence of unique elements

val list = List(1,2,3,4,2,3,4,99) 
val l2 = list.removeDuplicates 
// l2: scala.List[scala.Int] = List(1,2,3,4,99) 

Desde List es inmutable, usted no modifica la inicial List llamando removeDuplicates

Advertencia: (!) Como se ha mencionado por this tweet, esto no conserva el orden:

scala> val list = List(2,1,2,4,2,9,3) 
list: List[Int] = List(2, 1, 2, 4, 2, 9, 3) 

scala> val l2 = list.removeDuplicates 
l2: List[Int] = List(1, 4, 2, 9, 3) 

Para un Seq, ese método debería estar disponible en Scala2.8, de acuerdo con ticket 929.
Mientras tanto, tendrá que definir un método estático ad-hoc como el one seen here

Answer 3

Un método ad-hoc simple es sólo para añadir la lista a un conjunto, y utilizar desde allí:

val l = List(1,2,3,3,3,4,5,5,6,7,8,8,8,9,9) 
    val s = Set() ++ x 
    println(s) 

Produce:

> Set(5, 1, 6, 9, 2, 7, 3, 8, 4) 

Esto funciona para un Seq (o cualquier Iterable), pero no es necesario en 2.8, en donde el método RemoveDuplicates probablemente será más fácil de leer. Además, no estoy seguro sobre el rendimiento del tiempo de ejecución frente a una conversión más pensada.

Además, tenga en cuenta la pérdida de pedidos.

Answer 4

rollo su propio filtro uniq con la retención de orden:

scala> val l = List(1,2,3,3,4,6,5,6) 
l: List[Int] = List(1, 2, 3, 3, 4, 6, 5, 6) 

scala> l.foldLeft(Nil: List[Int]) {(acc, next) => if (acc contains next) acc else next :: acc }.reverse 
res0: List[Int] = List(1, 2, 3, 4, 6, 5) 

Answer 5

En 2.8, que es:

List(1,2,3,2,1).distinct // => List(1, 2, 3) 

Answer 6

En mi humilde opinión, todas las interpretaciones de la cuestión son falsas:

¿Cómo en Scala para encontrar artículos únicos en la lista?

Dada esta lista:

val ili = List (1, 2, 3, 4, 4, 3, 1, 1, 4, 1) 

el único elemento único en la lista es 2. Los otros artículos no son únicos.

ili.toSet.filter (i => ili.indexOf (i) == ili.lastIndexOf (i)) 

lo encontrará.

Answer 7

list.filter { x => list.count(_ == x) == 1 } 

Answer 8

lista.toSet lo hará ya que Set por definición solo contiene elementos únicos