SCALA-555: add RandomFixedSizeSample (#801)

Author: SergeiIonin

scala-core-collections-2/src/main/scala-2/com/baeldung/scala/randomfixedsizesample/RandomFixedSizeSample.scala

@@ -0,0 +1,50 @@
+package com.baeldung.scala.randomfixedsizesample
+
+import scala.annotation.tailrec
+import scala.util.Random
+
+object RandomFixedSizeSample extends App {
+
+  // 1. Using recursion and Random.nextInt
+  def getRandomSampleRec[T](list: List[T], size: Int): List[T] = {
+    @tailrec
+    def rec(xs: List[T], acc: List[T]): List[T] = {
+
+      if (acc.size == size) {
+        acc
+      } else {
+
+        val index = Random.nextInt(xs.size)
+        val (left, right) = xs.splitAt(index)
+        val (xsUpd, next) = if (right.nonEmpty) {
+          (left ::: right.tail, right.head)
+        } else {
+          (left.dropRight(1), left.tail.last)
+        }
+        rec(xsUpd, next :: acc)
+      }
+    }
+
+    if (size == 0) {
+      List.empty[T]
+    } else if (size > list.size) {
+      list
+    } else {
+      rec(list, List.empty[T])
+    }
+
+  }
+
+  // 2. Using zip with random numbers, sort and take
+  def getRandomSampleZip[T](list: List[T], size: Int): List[T] =
+    list
+      .map(elem => (Random.nextInt(), elem))
+      .sortBy(_._1)
+      .map(_._2)
+      .take(size)
+
+  // 3. Using shuffle and take
+  def getRandomSampleShuffle[T](list: List[T], size: Int): List[T] =
+    Random.shuffle(list).take(size)
+
+}

scala-core-collections-2/src/test/scala-2/com/baeldung/scala/randomfixedsizesample/RandomFixedSizeSampleSpec.scala

@@ -0,0 +1,70 @@
+package com.baeldung.scala.randomfixedsizesample
+
+import org.scalatest.wordspec.AnyWordSpec
+import org.scalatest.matchers.should.Matchers
+
+import scala.annotation.tailrec;
+
+class RandomFixedSizeSampleSpec extends AnyWordSpec with Matchers {
+
+  "RandomFixedSizeSample" should {
+    "create a random sample out of the initial List" in {
+      val list = List.range(0, 100)
+      val sampleSize = 10
+      val list_0 = RandomFixedSizeSample.getRandomSampleRec(list, sampleSize)
+      val list_1 = RandomFixedSizeSample.getRandomSampleZip(list, sampleSize)
+      val list_2 =
+        RandomFixedSizeSample.getRandomSampleShuffle(list, sampleSize)
+
+      list_0.size shouldBe sampleSize
+      list_1.size shouldBe sampleSize
+      list_2.size shouldBe sampleSize
+
+      list_0.toSet.size shouldBe list_0.size
+      list_1.toSet.size shouldBe list_1.size
+      list_2.toSet.size shouldBe list_2.size
+
+      isSorted(list_0) shouldBe false
+      isSorted(list_1) shouldBe false
+      isSorted(list_2) shouldBe false
+    }
+    "ensure getRandomSampleShuffle is the most performant, then goes getRandomSampleZip and then getRandomSampleRec" in {
+      val list = List.range(0, 10_000)
+      val sampleSize = 100
+
+      val start_0 = System.nanoTime()
+      RandomFixedSizeSample.getRandomSampleRec(list, sampleSize)
+      val end_0 = System.nanoTime()
+      val duration_0 = end_0 - start_0
+
+      val start_1 = System.nanoTime()
+      RandomFixedSizeSample.getRandomSampleZip(list, sampleSize)
+      val end_1 = System.nanoTime()
+      val duration_1 = end_1 - start_1
+
+      val start_2 = System.nanoTime()
+      RandomFixedSizeSample.getRandomSampleShuffle(list, sampleSize)
+      val end_2 = System.nanoTime()
+      val duration_2 = end_2 - start_2
+
+      duration_0 should be > duration_1
+      duration_1 should be > duration_2
+    }
+
+  }
+
+  def isSorted[T](list: List[T])(implicit o: Ordering[T]): Boolean = {
+    @tailrec def iter(head: T, tail: List[T]): Boolean =
+      if (tail.isEmpty) true
+      else if (o.lt(tail.head, head)) false
+      else {
+        iter(tail.head, tail.tail)
+      }
+
+    list match {
+      case Nil          => true
+      case head :: tail => iter(head, tail)
+    }
+  }
+
+}