আমি স্কালায় দু'জনের বেশি তালিকাকে একসাথে জিপ করতে পারি?

Question 1

নিম্নলিখিত স্কালা তালিকা দেওয়া:

val l = List(List("a1", "b1", "c1"), List("a2", "b2", "c2"), List("a3", "b3", "c3"))

কিভাবে আমি পেতে পারি:

List(("a1", "a2", "a3"), ("b1", "b2", "b3"), ("c1", "c2", "c3"))

যেহেতু জিপটি কেবল দুটি তালিকার সংমিশ্রণে ব্যবহৃত হতে পারে তাই আমার মনে হয় আপনাকে কোনওভাবে প্রধান তালিকাটি পুনরাবৃত্তি করতে হবে / হ্রাস করতে হবে। অবাক হওয়ার মতো বিষয় নয়, নিম্নলিখিতগুলি কাজ করে না:

scala> l reduceLeft ((a, b) => a zip b)
<console>:6: error: type mismatch;
 found   : List[(String, String)]
 required: List[String]
       l reduceLeft ((a, b) => a zip b)

কোনও পরামর্শ কীভাবে এটি করা যায়? আমি মনে করি এটি করার একটি খুব সহজ উপায় আমি মিস করছি।

আপডেট: আমি এমন একটি সমাধান খুঁজছি যা এম উপাদানগুলির প্রত্যেকের সাথে এন তালিকাগুলির একটি তালিকা নিতে পারে এবং এম টিপলএনগুলির একটি তালিকা তৈরি করতে পারে।

আপডেট 2: দেখা যাচ্ছে যে আমার নির্দিষ্ট ব্যবহারের ক্ষেত্রে তালিকার তালিকার চেয়ে তালিকার একটি তালিকা থাকা ভাল, সুতরাং আমি কুমড়োর প্রতিক্রিয়া গ্রহণ করছি accepting এটি একটি সহজ পদ্ধতি, কারণ এটি একটি স্থানীয় পদ্ধতি ব্যবহার করে।

Question 2

আমি বিশ্বাস করি না যে স্বেচ্ছাসেবী আকারের টিপলগুলির একটি তালিকা উত্পন্ন করা সম্ভব, তবে ট্রান্সপোজ ফাংশন ঠিক আপনার প্রয়োজন মতো করে যদি আপনি পরিবর্তে তালিকার একটি তালিকা পেতে আপত্তি না করেন।

Question 3

scala> (List(1,2,3),List(4,5,6),List(7,8,9)).zipped.toList
res0: List[(Int, Int, Int)] = List((1,4,7), (2,5,8), (3,6,9))

ভবিষ্যতের রেফারেন্সের জন্য।

Question 4

সুতরাং কোডের এই অংশটি ওপিটির প্রয়োজনীয়তার উত্তর দেবে না, এবং কেবল এটি নয় কারণ এটি একটি চার বছরের পুরানো থ্রেড, তবে এটি শিরোনাম প্রশ্নের উত্তর দেয় এবং সম্ভবত কেউ এটি কার্যকরও বলে মনে করতে পারে।

3 সংগ্রহ জিপ করতে:

as zip bs zip cs map { 
  case ((a,b), c) => (a,b,c)
}

Question 5

হ্যাঁ, সঙ্গে zip3 ।

Question 6

transposeকৌতুক করে একটি সম্ভাব্য অ্যালগরিদম হ'ল:

def combineLists[A](ss:List[A]*) = {
    val sa = ss.reverse;
    (sa.head.map(List(_)) /: sa.tail)(_.zip(_).map(p=>p._2 :: p._1))
}

উদাহরণ স্বরূপ:

combineLists(List(1, 2, 3), List(10,20), List(100, 200, 300))
// => List[List[Int]] = List(List(1, 10, 100), List(2, 20, 200))

উত্তরটি ইনপুটে সংক্ষিপ্ত তালিকার আকারে কাটা হয়েছে।

combineLists(List(1, 2, 3), List(10,20))
// => List[List[Int]] = List(List(1, 10), List(2, 20))

Question 7

সব বিভিন্ন শ্রেণীর যেমন তার বিভিন্ন tuple আকারের scala একইরূপে ( Tuple1, Tuple2, Tuple3, Tuple4, ..., Tuple22) যখন তারা থেকে সমস্ত উত্তরাধিকারী না Productবৈশিষ্ট্য যথেষ্ট তথ্য বহন করে না যে বৈশিষ্ট্য, আসলে tuples বিভিন্ন মাপের থেকে ডেটা মান ব্যবহার করতে যদি তারা সমস্ত একই ফাংশন দ্বারা ফিরে আসতে পারে। (এবং স্কালার জেনেরিকগুলিও এই কেসটি পরিচালনা করতে যথেষ্ট শক্তিশালী নয়))

আপনার সেরা বাজি হ'ল সমস্ত 22 টি টিউপল আকারের জিপ ফাংশনটির ওভারলোডগুলি লিখুন। একটি কোড জেনারেটর সম্ভবত এটিতে আপনাকে সহায়তা করবে।

Question 8

আপনি যদি অ্যাপ্লিকটিভ স্কালাজ / বিড়াল / (আপনার পছন্দসই ফাংশনাল লাইবটি এখানে sertোকান) রুটটি নীচে না যেতে চান তবে প্যাটার্ন ম্যাচিংয়ের উপায় হ'ল, যদিও (_, _)বাক্য গঠনটি বাসা বাঁধার সাথে কিছুটা বিশ্রী, তাই আসুন এটি পরিবর্তন করুন:

import scala.{Tuple2 => &}

for (i1 & i2 & i3 & i4 <- list1 zip list2 zip list3 zip list4) yield (i1, i2, i3, i4)

&এখানে একটি অবাধ পছন্দ, কিছু চমৎকার পোতা এটা করতে হবে এই রকম দেখায়। কোড পর্যালোচনা চলাকালীন আপনি সম্ভবত কয়েকটি উত্থিত ভ্রু পাবেন।

এটি আপনার যা কিছু zip(উদাহরণস্বরূপ Future) সাথে কাজ করা উচিত

Question 9

আমি বিশ্বাস করি না যে এটি পুনরাবৃত্তি না করে সম্ভব। একটি সাধারণ কারণ: আপনি যে ফাংশনটির জন্য জিজ্ঞাসা করছেন তার রিটার্নিং ধরণের সংজ্ঞা দিতে পারবেন না।

উদাহরণস্বরূপ, যদি আপনার ইনপুট হয় List(List(1,2), List(3,4)), তবে ফেরতের ধরন হবে List[Tuple2[Int]]। যদি এটিতে তিনটি উপাদান থাকে তবে রিটার্নের ধরণ থাকবে List[Tuple3[Int]]ইত্যাদি।

আপনি ফিরে আসতে পারেন List[AnyRef], বা এমনকি List[Product], এবং তারপরে প্রতিটি শর্তের জন্য একটি করে গুচ্ছ কেস তৈরি করতে পারেন ।

সাধারণ তালিকা স্থানান্তর হিসাবে, এটি কাজ করে:

def transpose[T](l: List[List[T]]): List[List[T]] = l match {
  case Nil => Nil
  case Nil :: _ => Nil
  case _ => (l map (_.head)) :: transpose(l map (_.tail))
}

Question 10

প্রোডাক্ট-flatZip কালেকশনটিতে আধ্যাত্মিক 22 পর্যন্ত অপারেশন রয়েছে ।

scala> List(1,2,3) flatZip Seq("a","b","c") flatZip Vector(1.0,2.0,3.0) flatZip Seq(9,8,7)
res1: com.github.marklister.collections.immutable.CollSeq4[Int,String,Double,Int] = 
CollSeq((1,a,1.0,9),
        (2,b,2.0,8),
        (3,c,3.0,7))

Question 11

স্কালাজ সহ:

import scalaz.Zip
import scalaz.std.list._

// Zip 3
Zip[List].ap.tuple3(List("a1", "b1"),
                    List("a2", "b2"),
                    List("a3", "b3"))

// Zip 4
Zip[List].ap.tuple4(List("a1", "b1"),
                    List("a2", "b2"),
                    List("a3", "b3"),
                    List("a4", "b4"))

// Zip 5
Zip[List].ap.tuple5(List("a1", "b1"),
                    List("a2", "b2"),
                    List("a3", "b3"),
                    List("a4", "b4"),
                    List("a5", "b5"))

5 এরও বেশি জন্য:

// Zip 6
Zip[List].ap.apply6(List("a1", "b1"),
                    List("a2", "b2"),
                    List("a3", "b3"),
                    List("a4", "b4"),
                    List("a5", "b5"),
                    List("a6", "b6"))((_, _, _, _, _, _))

// Zip 7
Zip[List].ap.apply7(List("a1", "b1"),
                    List("a2", "b2"),
                    List("a3", "b3"),
                    List("a4", "b4"),
                    List("a5", "b5"),
                    List("a6", "b6"),
                    List("a7", "b7"))((_, _, _, _, _, _, _))

...

// Zip 12
Zip[List].ap.apply12(List("a1", "b1"),
                     List("a2", "b2"),
                     List("a3", "b3"),
                     List("a4", "b4"),
                     List("a5", "b5"),
                     List("a6", "b6"),
                     List("a7", "b7"),
                     List("a8", "b8"),
                     List("a9", "b9"),
                     List("a10", "b10"),
                     List("a11", "b11"),
                     List("a12", "b12"))((_, _, _, _, _, _, _, _, _, _, _, _))