अनुमान के अनुसार एक अनुक्रम को दो टुकड़ों में कैसे विभाजित करें?

Question

मैं एक अनुक्रम द्वारा एक अनुक्रम को दो सूचियों में कैसे विभाजित करूं?

वैकल्पिक: मैं filter और filterNot का उपयोग कर सकता हूं, या अपनी खुद की विधि लिख सकता हूं, लेकिन क्या कोई बेहतर सामान्य (अंतर्निहित) विधि नहीं है?

Answer 1

partition पद्धति का उपयोग करके द्वारा:

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

Answer 2

आप scalex.org पर एक नज़र डालें करना चाह सकते हैं - यह आप उनके हस्ताक्षर द्वारा कार्यों के लिए स्केला मानक पुस्तकालय खोज करने के लिए अनुमति देता है। उदाहरण के लिए, निम्न लिखें:

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

आप विभाजन देखना होगा।

Answer 3

अच्छा partition वह चीज था जो आप चाहते थे - एक और तरीका है जो दो: span में एक सूची को विभाजित करने के लिए भविष्यवाणी का उपयोग करता है।

पहला, partition सभी "सत्य" तत्वों को एक सूची में और दूसरी सूची में अन्य लोगों को रखेगा।

span सभी तत्वों को एक सूची में तब तक रखा जाएगा जब तक कोई तत्व "झूठा" (भविष्यवाणी के संदर्भ में) न हो। उस बिंदु से आगे, यह तत्वों को दूसरी सूची में रखेगा।

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

Answer 4

तुम भी foldLeft उपयोग कर सकते हैं अगर आप कुछ थोड़ा अतिरिक्त जरूरत है। मैं तो बस इस तरह की कुछ कोड लिखा था जब विभाजन इसे काट नहीं था:

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

आप अधिक से अधिक 2 टुकड़ों में एक सूची को विभाजित करना चाहते हैं, तो गुना की अनदेखी, आप (कुछ इस तरह संशोधित इस्तेमाल कर सकते हैं अगर आप इनट्स की खोज करने की आवश्यकता है)

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"})