স্কেলে সূচক সহ কার্যকর পুনরাবৃত্তি

Question 1

যেহেতু স্কালার forসূচি সহ পুরানো জাভা স্টাইলের লুপ নেই,

// does not work
val xs = Array("first", "second", "third")
for (i=0; i<xs.length; i++) {
  println("String #" + i + " is " + xs(i))
}

কীভাবে আমরা দক্ষতার সাথে পুনরাবৃত্তি করতে পারি এবং ব্যবহার না করেই পারি var ?

আপনি এটি করতে পারে

val xs = Array("first", "second", "third")
val indexed = xs zipWithIndex
for (x <- indexed) println("String #" + x._2 + " is " + x._1)

তবে তালিকাটি দু'বার বিভ্রান্ত হয়েছে - খুব দক্ষ নয়।

Question 2

দু'বার ট্র্যাভারিংয়ের চেয়ে অনেক খারাপ, এটি জোড়াগুলির মধ্যবর্তী অ্যারে তৈরি করে। আপনি ব্যবহার করতে পারেন view। আপনি যখন করেন collection.view, আপনি পরবর্তী কলগুলি পুনরাবৃত্তির সময় অলসভাবে অভিনয় হিসাবে ভাবতে পারেন। আপনি যদি যথাযথভাবে উপলব্ধি করা সংগ্রহটি ফিরে পেতে চান তবে আপনি forceশেষে কল করুন। এখানে এটি অকেজো এবং ব্যয়বহুল হবে। সুতরাং আপনার কোড পরিবর্তন করুন

for((x,i) <- xs.view.zipWithIndex) println("String #" + i + " is " + x)

Question 3

এটা তোলে উল্লিখিত হয়েছে Scala যে করে জন্য সিনট্যাক্স আছে forলুপ:

for (i <- 0 until xs.length) ...

বা সহজভাবে

for (i <- xs.indices) ...

তবে আপনি দক্ষতাও চেয়েছিলেন। এটা পরিনত হয় যে Scala forসিনট্যাক্স আসলে যেমন উচ্চতর ক্রম পদ্ধতি জন্য অন্বিত চিনি map, foreachইত্যাদি যেমন, কিছু কিছু ক্ষেত্রে এই লুপ অদক্ষ হতে পারে, উদাঃ কিভাবে নিখুত এবং Scala মধ্যে লুপ-comprehensions জন্য?

(সুসংবাদটি হ'ল স্কালার দল এটি উন্নতি করার জন্য কাজ করছে Here বাগ ট্র্যাকারে এই বিষয়টি এখানে রয়েছে: https://issues.scala-lang.org/browse/SI-4633 )

চূড়ান্ত দক্ষতার জন্য, কেউ একটি whileলুপ ব্যবহার করতে পারেন বা, যদি আপনি varলেজ পুনরাবৃত্তিগুলির ব্যবহারগুলি অপসারণ করার জন্য জোর দেন :

import scala.annotation.tailrec

@tailrec def printArray(i: Int, xs: Array[String]) {
  if (i < xs.length) {
    println("String #" + i + " is " + xs(i))
    printArray(i+1, xs)
  }
}
printArray(0, Array("first", "second", "third"))

নোট করুন যে পদ্ধতিটি আসলে টেল রিকার্সিভ তা নিশ্চিত করার জন্য al চ্ছিক @tailrec টীকাটি কার্যকর। স্কালা সংকলকটি সময় লুপগুলির সমতুল্য বাইট কোডে পুচ্ছ-পুনরাবৃত্ত কলগুলি অনুবাদ করে।

Question 4

আরও একটি উপায়:

scala> val xs = Array("first", "second", "third")
xs: Array[java.lang.String] = Array(first, second, third)

scala> for (i <- xs.indices)
     |   println(i + ": " + xs(i))
0: first
1: second
2: third

Question 5

আসলে, স্কালায় সূচি সহ পুরানো জাভা-স্টাইলের লুপ রয়েছে:

scala> val xs = Array("first","second","third")
xs: Array[java.lang.String] = Array(first, second, third)

scala> for (i <- 0 until xs.length)
     | println("String # " + i + " is "+ xs(i))

String # 0 is first
String # 1 is second
String # 2 is third

কোথায় 0 until xs.lengthবা 0.until(xs.length)এমন কোনও RichIntপদ্ধতি যা Rangeলুপিংয়ের জন্য উপযুক্ত।

এছাড়াও, আপনি এটি দিয়ে লুপ চেষ্টা করতে পারেন to:

scala> for (i <- 0 to xs.length-1)
     | println("String # " + i + " is "+ xs(i))
String # 0 is first
String # 1 is second
String # 2 is third

Question 6

এ কেমন?

val a = Array("One", "Two", "Three")
a.foldLeft(0) ((i, x) => {println(i + ": " + x); i + 1;} )

আউটপুট:

0: One
1: Two
2: Three

Question 7

স্কেলে লুপিং বেশ সহজ। প্রাক্তন জন্য আপনার পছন্দসই কোন অ্যারে তৈরি করুন।

val myArray = new Array[String](3)
myArray(0)="0";
myArray(1)="1";
myArray(2)="2";

লুপের প্রকার,

for(data <- myArray)println(data)

for (i <- 0 until myArray.size)
println(i + ": " + myArray(i))

Question 8

প্রকৃতপক্ষে, zipWithIndexকোনও সংগ্রহকে কল করা এটিকে অতিক্রম করবে এবং জোড়গুলির জন্য একটি নতুন সংগ্রহ তৈরি করবে। এটি এড়াতে, আপনি zipWithIndexসংগ্রহের জন্য কেবল পুনরুক্তিকারীকে কল করতে পারেন । এটি কেবলমাত্র একটি নতুন পুনরাবৃত্তির ফিরিয়ে দেবে যা পুনরাবৃত্তির সময় সূচকের উপর নজর রাখে, সুতরাং অতিরিক্ত সংগ্রহ বা অতিরিক্ত ট্র্যাভারসিং তৈরি না করে।

এই হল কিভাবে scala.collection.Iterator.zipWithIndexবর্তমানে 2.10.3 বাস্তবায়িত হয়:

  def zipWithIndex: Iterator[(A, Int)] = new AbstractIterator[(A, Int)] {
    var idx = 0
    def hasNext = self.hasNext
    def next = {
      val ret = (self.next, idx)
      idx += 1
      ret
    }
  }

এটি সংগ্রহে ভিউ তৈরির চেয়ে কিছুটা বেশি দক্ষ হওয়া উচিত।

Question 9

স্টাডলিবের এমন কিছুই নেই যা টুপল আবর্জনা তৈরি না করে এটি আপনার পক্ষে করবে, তবে এটি নিজের লেখা খুব বেশি কঠিন নয়। দুর্ভাগ্যক্রমে আমি কখনই উপযুক্ত ক্যানবিল্ড থেকে এই জাতীয় জিনিসগুলিকে সংগ্রহ করার ধরণের ক্ষেত্রে জেনেরিক তৈরি করার জন্য অন্তর্নিহিত অপ্রতুলতা কীভাবে করা যায় তা বোঝার মাথা ঘামাইনি, তবে যদি এটি সম্ভব হয় তবে আমি নিশ্চিত যে কেউ আমাদের আলোকিত করবেন। :)

def foreachWithIndex[A](as: Traversable[A])(f: (Int,A) => Unit) {
  var i = 0
  for (a <- as) {
    f(i, a)
    i += 1
  }
}

def mapWithIndex[A,B](in: List[A])(f: (Int,A) => B): List[B] = {
  def mapWithIndex0(in: List[A], gotSoFar: List[B], i: Int): List[B] = {
    in match {
      case Nil         => gotSoFar.reverse
      case one :: more => mapWithIndex0(more, f(i, one) :: gotSoFar, i+1)
    }
  }
  mapWithIndex0(in, Nil, 0)
}

// Tests....

@Test
def testForeachWithIndex() {
  var out = List[Int]()
  ScalaUtils.foreachWithIndex(List(1,2,3,4)) { (i, num) =>
    out :+= i * num
  }
  assertEquals(List(0,2,6,12),out)
}

@Test
def testMapWithIndex() {
  val out = ScalaUtils.mapWithIndex(List(4,3,2,1)) { (i, num) =>
    i * num
  }

  assertEquals(List(0,3,4,3),out)
}

Question 10

পুনরাবৃত্তি করার আরও কয়েকটি উপায়:

scala>  xs.foreach (println) 
first
second
third

ভবিষ্যদ্বাণী, এবং অনুরূপ, মানচিত্র, যা কিছু ফেরত দেবে (ফাংশনের ফলাফল যা মুদ্রণের জন্য, ইউনিট, সুতরাং ইউনিটের একটি তালিকা)

scala> val lens = for (x <- xs) yield (x.length) 
lens: Array[Int] = Array(5, 6, 5)

সূচকের সাথে নয়, উপাদানগুলির সাথে কাজ করুন

scala> ("" /: xs) (_ + _) 
res21: java.lang.String = firstsecondthird

ভাঁজ

for(int i=0, j=0; i+j<100; i+=j*2, j+=i+2) {...}
পুনরাবৃত্তি দিয়ে করা যেতে পারে:

def ijIter (i: Int = 0, j: Int = 0, carry: Int = 0) : Int =
  if (i + j >= 100) carry else 
    ijIter (i+2*j, j+i+2, carry / 3 + 2 * i - 4 * j + 10)

বহনকারী অংশটি কেবলমাত্র উদাহরণ এবং i এবং j এর সাথে কিছু করা। এটি কোন ইন্টি হতে হবে না।

সহজ স্টাফ জন্য, লুপ জন্য স্বাভাবিক কাছাকাছি:

scala> (1 until 4)
res43: scala.collection.immutable.Range with scala.collection.immutable.Range.ByOne = Range(1, 2, 3)

scala> (0 to 8 by 2)   
res44: scala.collection.immutable.Range = Range(0, 2, 4, 6, 8)

scala> (26 to 13 by -3)
res45: scala.collection.immutable.Range = Range(26, 23, 20, 17, 14)

বা আদেশ ছাড়াই:

List (1, 3, 2, 5, 9, 7).foreach (print)

Question 11

আমি নিম্নলিখিত পন্থাগুলি আছে

object HelloV2 {

   def main(args: Array[String]) {

     //Efficient iteration with index in Scala

     //Approach #1
     var msg = "";

     for (i <- args.indices)
     {
       msg+=(args(i));
     }
     var msg1="";

     //Approach #2
     for (i <- 0 until args.length) 
     {
       msg1 += (args(i));
     }

     //Approach #3
     var msg3=""
     args.foreach{
       arg =>
        msg3 += (arg)
     }


      println("msg= " + msg);

      println("msg1= " + msg1);

      println("msg3= " + msg3);

   }
}

Question 12

একটি সহজ এবং কার্যকর উপায়, বাস্তবায়ন থেকে অনুপ্রাণিত transformমধ্যে SeqLike.scala

    var i = 0
    xs foreach { el =>
      println("String #" + i + " is " + xs(i))
      i += 1
    }

Question 13

প্রস্তাবিত সমাধানগুলি সত্য হয় যে তারা স্পষ্টভাবে কোনও সংগ্রহের উপর পুনরাবৃত্তি করে বা সংগ্রহটিকে কোনও কার্যক্রমে স্টাফ করে। স্কালার স্বাভাবিক প্রতিচ্ছবিগুলির সাথে লেগে থাকা এবং সূচিটি স্বাভাবিক মানচিত্রের মধ্যে রাখা - বা ফোরচ-পদ্ধতিগুলির মধ্যে। এটি মেমোজাইজিং ব্যবহার করে করা যেতে পারে। ফলস্বরূপ কোডটি দেখতে পারে

myIterable map (doIndexed(someFunction))

এই উদ্দেশ্য অর্জনের জন্য এখানে একটি উপায়। নিম্নলিখিত ইউটিলিটি বিবেচনা করুন:

object TraversableUtil {
    class IndexMemoizingFunction[A, B](f: (Int, A) => B) extends Function1[A, B] {
        private var index = 0
        override def apply(a: A): B = {
            val ret = f(index, a)
            index += 1
            ret
        }
    }

    def doIndexed[A, B](f: (Int, A) => B): A => B = {
        new IndexMemoizingFunction(f)
    }
}

আপনার যা প্রয়োজন তা এটি ইতিমধ্যে। আপনি উদাহরণস্বরূপ এটি প্রয়োগ করতে পারেন:

import TraversableUtil._
List('a','b','c').map(doIndexed((i, char) => char + i))

তালিকার ফলাফল যা

List(97, 99, 101)

এইভাবে, আপনি আপনার কার্যকর ফাংশন মোড়ানো ব্যয় করে স্বাভাবিক ট্র্যাভারেবল-ফাংশন ব্যবহার করতে পারেন। উপভোগ করুন!