¿Cómo dividir una secuencia en dos partes por predicado?

Question

¿Cómo se divide una secuencia en dos listas por un predicado?

Alternativa: Puedo usar filter y filterNot, o escribir mi propio método, pero ¿no hay un mejor método más general (incorporado)?

Answer 1

Mediante el uso de partition método:

scala> List(1,2,3,4).partition(x => x % 2 == 0) 
res0: (List[Int], List[Int]) = (List(2, 4),List(1, 3)) 

Answer 2

Es posible que desee echar un vistazo a scalex.org - Permite realizar búsquedas en la biblioteca estándar Scala de funciones mediante su firma. Por ejemplo, escriba lo siguiente:

List[A] => (A => Boolean) => (List[A], List[A]) 

Veríais partición.

Answer 3

Bueno, partition era lo que quería, hay otro método que también usa un predicado para dividir una lista en dos: span.

El primero, partition pondrá todos los elementos "verdaderos" en una lista, y los otros en la segunda lista.

span pondrá todos los elementos en una lista hasta que un elemento sea "falso" (en términos del predicado). A partir de ese momento, colocará los elementos en la segunda lista.

scala> Seq(1,2,3,4).span(x => x % 2 == 0) 
res0: (Seq[Int], Seq[Int]) = (List(),List(1, 2, 3, 4)) 

Answer 4

También puede usar foldLeft si necesita algo más. Acabo de escribir un código como éste cuando la partición no lo consiguió:

val list:List[Person] = /* get your list */ 
val (students,teachers) = 
    list.foldLeft(List.empty[Student],List.empty[Teacher]) { 
    case ((acc1, acc2), p) => p match { 
     case s:Student => (s :: acc1, acc2) 
     case t:Teacher => (acc1, t :: acc2) 
    } 
    } 

Answer 5

Si desea dividir una lista en más de 2 piezas, y hacer caso omiso de los límites, se puede usar algo como esto (modificar si necesita buscar ints)

def split(list_in: List[String], search: String): List[List[String]] = { 
    def split_helper(accum: List[List[String]], list_in2: List[String], search: String): List[List[String]] = { 
    val (h1, h2) = list_in2.span({x: String => x!= search}) 
    val new_accum = accum :+ h1 
    if (h2.contains(search)) { 
     return split_helper(new_accum, h2.drop(1), search) 
    } 
    else { 
    return accum 
    } 
    } 
    return split_helper(List(), list_in, search) 
} 

// TEST 

// split(List("a", "b", "c", "d", "c", "a"), {x: String => x != "x"})