Modify Scala Testing

archive/s/scala/Baklava.scala

@@ -1,10 +1,13 @@
-import scala.math.abs
+object Baklava:
+  def generate(size: Int): Seq[String] =
+    for i <- -size to size yield
+      val spaces = i.abs
+      val stars = (size * 2 + 1) - 2 * spaces
+      " " * spaces + "*" * stars
 
-object Baklava {
-  def main(args: Array[String]): Unit = {
-    for (i <- -10.until(11)) {
-        var numSpaces = abs(i)
-        println(" " * numSpaces + "*" * (21 - 2 * numSpaces))
-    }
-  }
-}
+  def main(args: Array[String]): Unit =
+    val size =
+      if args.nonEmpty then args(0).toInt
+      else 10
+
+    generate(size).foreach(println)

archive/s/scala/BubbleSort.scala

@@ -1,50 +1,41 @@
-import scala.reflect.ClassTag
-
-object BubbleSort {
-  def main(args: Array[String]) {
-    // verify inputs are being provided
-    parseInput(args) match {
-      case None => println("Usage: please provide a list of at least two integers to sort in the format \"1, 2, 3, 4, 5\"")
-      case Some(inputArr) => {
-        if (inputArr.length < 2) {
-          println("Usage: please provide a list of at least two integers to sort in the format \"1, 2, 3, 4, 5\"")
-        }
-        else {
-          val output = bubbleSort(inputArr).mkString(", ")
-          println(output)
-        }
-      }
-    }
-  }
-
-  def parseInput(args: Array[String]): Option[Array[Int]] = args.length match {
-    case 0 => None
-    case _ => try {
-      Some(args(0).split(",").map(_.trim).map(_.toInt))
-    } catch {
-      case e: Throwable => None
-    }
-  }
-
-  // bubble the current element
-
-  // bubble sort increasing elements
-  // note on signature:
-  // ClassTag elements help construct Array quen using ++ (instead of falling back to ArraySeq)
-  // Elements of array implement Ordered, so we can compare 2 instances of T using ==, <, >, etc.
-  def bubbleSort[T <% Ordered[T]: ClassTag](arr: Array[T]): Array[T] = {
-    def bubble(a: Array[T]): Array[T] = a.length match {
-      case 0 => a
-      case 1 => a
-      case _ => {
-        if (a(0) > a(1)) {
-          a.slice(1, 2) ++ bubble(a.slice(0, 1) ++ a.slice(2, a.length))
-        }
-        else {
-          a.slice(0, 1) ++ bubble(a.slice(1, a.length))
-        }
-      }
-    }
-    arr.foldLeft(arr)((xs: Array[T], cur: T) => bubble(xs))
-  }
-}
+import scala.annotation.tailrec
+import scala.math.Ordering.Implicits.infixOrderingOps
+
+object BubbleSort:
+
+  private val usage =
+    """Usage: please provide a list of at least two integers to sort in the format "1, 2, 3, 4, 5""""
+
+  def main(args: Array[String]): Unit =
+    val result =
+      args.headOption
+        .flatMap(parse)
+        .map(bubbleSort)
+        .map(_.mkString(", "))
+        .getOrElse(usage)
+
+    println(result)
+
+  private def parse(input: String): Option[List[Int]] =
+    val parts = input.split(',').map(_.trim).toList
+    val nums = parts.flatMap(_.toIntOption)
+    Option.when(nums.size >= 2 && nums.size == parts.size)(nums)
+
+  private def bubbleSort[T: Ordering](xs: List[T]): List[T] =
+    @tailrec
+    def pass(list: List[T], acc: List[T] = Nil, swapped: Boolean = false): (List[T], Boolean) =
+      list match
+        case a :: b :: tail if a > b =>
+          pass(a :: tail, b :: acc, true)
+        case a :: tail =>
+          pass(tail, a :: acc, swapped)
+        case Nil =>
+          (acc.reverse, swapped)
+
+    @tailrec
+    def loop(current: List[T]): List[T] =
+      val (next, swapped) = pass(current)
+      if swapped then loop(next)
+      else next
+
+    loop(xs)

archive/s/scala/Capitalize.scala

@@ -1,14 +1,5 @@
-object Capitalize {
-  def main(args: Array[String]) {
-    val inputStr: Option[String] = args.length match {
-      case 0 => Some("")
-      case _ => Some(args(0))
-    }
-    if (inputStr.get.length < 1) {
-      println("Usage: please provide a string")
-    }
-    else {
-      inputStr.map(_.capitalize).map(println)
-    }
-  }
-}
+object Capitalize:
+  def main(args: Array[String]): Unit =
+    args.headOption.filter(_.nonEmpty) match
+      case Some(str) => println(str.capitalize)
+      case None      => println("Usage: please provide a string")

archive/s/scala/EvenOdd.scala

@@ -1,20 +1,13 @@
-// Scala Program to check if input number is Odd or Even
+import scala.util.Try
 
-import scala.util.{Try, Success, Failure}
+object EvenOdd:
+  private val usage = "Usage: please input a number"
 
-object EvenOdd 
-{
-    def check_even_odd(num: Int): String = { 
-        val result = if (num%2==0) "Even" else "Odd"
-        return result
-    }
+  def main(args: Array[String]): Unit =
+    val result =
+      args.headOption
+        .flatMap(a => Try(a.toInt).toOption)
+        .map(n => if n % 2 == 0 then "Even" else "Odd")
+        .getOrElse(usage)
 
-    // Driver Code 
-    def main(args: Array[String]) 
-    {
-        Try(args(0).toInt) match {
-            case Failure(_) => println("Usage: please input a number")
-            case Success(m) => println(check_even_odd(m))
-        }
-    }
-} 
+    println(result)

archive/s/scala/Factorial.scala

@@ -1,32 +1,18 @@
-// Scala Program to calculate 
-// Factorial of a number 
-
 import scala.util.Try
 
-// Creating object 
-object Factorial 
-{ 
-  // Iterative way to calculate
-  // factorial
-  def factorial(n: Int): Int = { 
-    var f = 1
-    for(i <- 1 to n) 
-    { 
-        f = f * i; 
-    } 
+object Factorial:
+  private val usage = "Usage: please input a non-negative integer"
+
+  def main(args: Array[String]): Unit =
+    val result =
+      args.headOption
+        .flatMap(a => Try(a.toInt).toOption)
+        .filter(_ >= 0)
+        .map(factorial)
 
-    return f 
-  } 
+    result match
+      case Some(value) => println(value)
+      case None => println(usage)
 
-  // Driver Code 
-  def main(args: Array[String]) 
-  {
-    val m = Try(args(0).toInt).getOrElse(-1)
-    if (m < 0) {
-      println("Usage: please input a non-negative integer")
-    }
-    else {
-      println(factorial(m))
-    }
-  } 
-} 
+  private def factorial(n: Int): Int =
+    (1 to n).product

archive/s/scala/Fibonacci.scala

@@ -1,23 +1,23 @@
-import scala.util.{Try, Success, Failure}
+object Fibonacci:
 
-object Fibonacci {
+  private val fibs: LazyList[BigInt] =
+    BigInt(1) #:: BigInt(1) #:: fibs.zip(fibs.tail).map(_ + _)
+
+  private val usage =
+    "Usage: please input the count of fibonacci numbers to output"
 
-  def fibonacci(n: Int) = {
-    var a = 0
-    var b = 1
-    for (i <- 1 to n) {
-      println(s"$i: $b")
-      val c = a + b
-      a = b
-      b = c
-    }
-  }
+  def main(args: Array[String]): Unit =
+    val output =
+      for
+        arg <- args.headOption
+        n <- arg.toIntOption if n >= 0
+      yield
+        if n == 0 then ""
+        else
+          fibs
+            .take(n)
+            .zipWithIndex
+            .map((f, i) => s"${i + 1}: $f")
+            .mkString("\n")
 
-
-  def main(args: Array[String]) = {
-    Try(args(0).toInt) match {
-      case Failure(_) => println("Usage: please input the count of fibonacci numbers to output")
-      case Success(n) => fibonacci(n)
-    }
-  }
-}
+    println(output.getOrElse(usage))

archive/s/scala/FileInputOutput.scala

@@ -1,41 +1,30 @@
-import scala.io.Source
-import java.io.{FileNotFoundException, IOException, File, FileOutputStream, PrintWriter}
+import java.nio.charset.StandardCharsets
+import java.nio.file.{Files, Path, Paths}
+import scala.jdk.CollectionConverters.*
+import scala.util.Try
 
-object FileInputOutput {
-  // reading file then write to stdout
-  // write exception when fail
-  def readFromFile(filename: String) {
-    try {
-      val buffer = Source.fromFile(filename)
-      val lines = buffer.getLines
+extension (p: Path)
+  def readLines: Try[List[String]] =
+    Try(Files.readAllLines(p, StandardCharsets.UTF_8).asScala.toList)
 
-      lines.foreach(println)
-      buffer.close
-    } catch {
-      case e: FileNotFoundException => println(s"File ${filename} does not exist.")
-      case e: IOException => println(s"I/O Exception when reading from ${filename}.")
-      case e: Throwable => println(s"Error ${e.getMessage} when reading from ${filename}.")
-    }
-  }
+  def writeString(content: String): Try[Unit] =
+    Try(Files.writeString(p, content, StandardCharsets.UTF_8)).map(_ => ())
 
-  // write to file
-  // stdout exception when fail
-  def writeToFile(filename: String, contents: String) {
-    try {
-      val writer = new PrintWriter(new File(filename))
-      writer.write(contents)
-      writer.close
-    } catch {
-      case e: FileNotFoundException => println(s"Cannot write into file ${filename}.")
-      case e: Throwable => println(s"Error ${e.getMessage} when writing to file ${filename}.")
-    }
-  }
+object FileInputOutput:
+  private val path = Paths.get("output.txt")
+  private val content =
+    """I am a string.
+      |I am also a string.
+      |Scala is fun!""".stripMargin
 
-  def main(args: Array[String]) {
-    // write succesfully
-    writeToFile("output.txt", "I am a string.\nI am also a string.\nScala is fun!\n")
+  def main(args: Array[String]): Unit =
+    val program =
+      for
+        _ <- path.writeString(content)
+        lines <- path.readLines
+      yield lines
 
-    // read successfully
-    readFromFile("output.txt")
-  }
-}
+    program.fold(
+      err => System.err.println(s"File operation failed: ${err.getMessage}"),
+      res => res.foreach(println)
+    )

archive/s/scala/FizzBuzz.scala

@@ -1,19 +1,9 @@
-object FizzBuzz {
-
-  def main(args: Array[String]): Unit = {
-    for (i <- 1.until(101)) {
-      var output: String = ""
-      if (i % 3 == 0) {
-        output += "Fizz"
-      }
-      if (i % 5 == 0) {
-        output += "Buzz"
-      }
-      if (output.isEmpty) {
-        output += i
-      }
-      println(output)
-    }
-  }
-
-}
+object FizzBuzz:
+  def main(args: Array[String]): Unit =
+    (1 to 100).map { i =>
+      (i % 3, i % 5) match
+        case (0, 0) => "FizzBuzz"
+        case (0, _) => "Fizz"
+        case (_, 0) => "Buzz"
+        case _ => i.toString
+    } foreach println

archive/s/scala/HelloWorld.scala

@@ -1,3 +1,3 @@
-object HelloWorld extends App {
-  println("Hello, World!")
-}
+object HelloWorld:
+  def main(args: Array[String]): Unit =
+    println("Hello, World!")