scala - sirve - tesis sobre youtube pdf

Cómo en Scala para encontrar artículos únicos en la Lista

Question

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

Answer 1

En 2.8, es:

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

Answer 2

Haga rodar su propio filtro uniq con la retención de pedidos:

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 3

Imho, todas las interpretaciones de la pregunta 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 4

Si se refiere al Código Rosetta: Cree una secuencia de elementos únicos

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)

Como List es inmutable, no modificará la List inicial llamando a removeDuplicates

Advertencia: como se menciona en este 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 el ticket 929 .
Mientras tanto, necesitarás definir un método estático ad-hoc como el que se ve aquí

Answer 5

Un método ad-hoc simple es simplemente agregar la Lista a un Conjunto, y usar 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, donde el método removeDuplicates probablemente será más legible. 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 orden perdida.

Answer 6

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

Answer 7

La manera más eficiente de preservar la orden de hacer esto sería usar 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)
}

Podemos ajustar esto en una sintaxis más agradable usando 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 8

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