init

GitPrivacy: bEo5O1lqfvITbSRgspJwRgLm6o+nTuIdQ7Vza3c22BT+u+3sFNAJ/8p2mDz0l4iNTSLgP9a9vQA= eu6AVfO7A6HqaVB4yxON/gBUCrlljfDTxiQ3yeXz4wigqlAlpDdZT+A+QzctHxtoq6+4kDKChxo=

Author: William Raendchen

.gitignore

@@ -0,0 +1,15 @@
+/project/project/target/
+/project/target/
+/target
+/.idea/libraries
+/.idea/modules/scalaandjava.iml
+/.bsp/sbt.json
+/.idea/.name
+/.idea/uiDesigner.xml
+/.idea/modules/
+/.idea/vcs.xml
+/.idea/modules.xml
+/.idea/misc.xml
+/.idea/scala_compiler.xml
+/.idea/scala_settings.xml
+/.idea/compiler.xml

.idea/.gitignore

@@ -0,0 +1,9 @@
+version = 3.8.2
+runner.dialect = scala3
+
+maxColumn = 120
+align.preset = most
+danglingParentheses.preset = true
+rewrite.rules = [RedundantBraces, RedundantParens]
+binPack.parentConstructors = false
+trailingCommas = keep

.idea/codeStyles/Project.xml

@@ -0,0 +1,13 @@
+import scala.collection.Seq
+
+ThisBuild / version      := "0.0.1-SNAPSHOT"
+ThisBuild / scalaVersion := "3.6.1"
+ThisBuild / javacOptions ++= Seq("--release", "17")
+
+libraryDependencies ++= Seq(
+  "com.lihaoyi"                   %% "upickle"      % "4.0.2",
+  "com.softwaremill.sttp.client4" %% "core"         % "4.0.0-M19",
+  "org.scalatest"                 %% "scalatest"    % "3.2.18"   % Test,
+  "org.scalatestplus"             %% "mockito-5-12" % "3.2.19.0" % Test,
+  "org.scalamock"                 %% "scalamock"    % "6.0.0"    % Test,
+)

.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1 @@
+sbt.version = 1.10.4

.idea/sbt.xml

@@ -0,0 +1,2 @@
+addSbtPlugin("org.jetbrains.scala" % "sbt-ide-settings" % "1.1.2")
+addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.3.0")

.scalafmt.conf

@@ -0,0 +1,17 @@
+package JavaPlayground;
+
+import ScalaPlayground.RomanNumerals.ScalaRomansPipeline;
+
+class App {
+    public static void main(String[] args) {
+        JavaRomans javaRomans = new JavaRomans();
+        System.out.println(javaRomans.toNumeral(999));
+
+        ScalaRomansPipeline scalaRomansPipeline = new ScalaRomansPipeline();
+        System.out.println(scalaRomansPipeline.toNumeral(999));
+
+        ScalaCalculator calculator = new ScalaCalculator();
+        System.out.println(calculator.add(1, 2));
+    }
+}
+

build.sbt

@@ -0,0 +1,37 @@
+package JavaPlayground;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class JavaRomans {
+    private static final List<Map.Entry<Integer, String>> valueList = List.of(
+        Map.entry(1000, "M"),
+        Map.entry(900, "CM"),
+        Map.entry(500, "D"),
+        Map.entry(400, "CD"),
+        Map.entry(100, "C"),
+        Map.entry(90, "XC"),
+        Map.entry(50, "L"),
+        Map.entry(40, "XL"),
+        Map.entry(10, "X"),
+        Map.entry(9, "IX"),
+        Map.entry(5, "V"),
+        Map.entry(4, "IV"),
+        Map.entry(1, "I")
+    );
+
+    public String toNumeral(Integer number) {
+        StringBuilder sb = new StringBuilder();
+        AtomicInteger remaining = new AtomicInteger(number);
+
+        valueList.forEach(entry -> {
+            while (remaining.get() >= entry.getKey()) {
+                remaining.addAndGet(-entry.getKey());
+                sb.append(entry.getValue());
+            }
+        });
+
+        return sb.toString();
+    }
+}

project/build.properties

@@ -0,0 +1,7 @@
+package JavaPlayground
+
+class ScalaCalculator:
+  def add(a: Int, b: Int): Int      = a + b
+  def subtract(a: Int, b: Int): Int = a - b
+  def multiply(a: Int, b: Int): Int = a * b
+  def divide(a: Int, b: Int): Int   = a / b

project/plugins.sbt

@@ -0,0 +1,14 @@
+package ScalaPlayground
+
+import JavaPlayground.JavaRomans
+import ScalaPlayground.RomanNumerals.ScalaRomansPipeline
+
+object App {
+  def main(args: Array[String]): Unit = {
+    val javaRomans = new JavaRomans()
+    println(javaRomans.toNumeral(1996))
+
+    val scalaRomans = ScalaRomansPipeline()
+    println(scalaRomans.toNumeral(1996))
+  }
+}

src/main/java/JavaPlayground/App.java

@@ -0,0 +1,76 @@
+package ScalaPlayground.RomanNumerals
+
+trait Romans:
+  def toNumeral(number: Int): String
+  def toInt(roman: String): Int
+
+class ScalaRomansImperative extends Romans:
+  private val valueList: Vector[(Int, String)] = Vector(
+    1000 -> "M",
+    900  -> "CM",
+    500  -> "D",
+    400  -> "CD",
+    100  -> "C",
+    90   -> "XC",
+    50   -> "L",
+    40   -> "XL",
+    10   -> "X",
+    9    -> "IX",
+    5    -> "V",
+    4    -> "IV",
+    1    -> "I"
+  )
+
+  override def toNumeral(number: Int): String = {
+    val sb        = new StringBuilder
+    var remaining = number
+
+    for ((value, numeral) <- valueList) {
+      while (remaining >= value) {
+        sb.append(numeral)
+        remaining -= value
+      }
+    }
+
+    sb.toString()
+  }
+  
+  override def toInt(roman: String): Int = ???
+end ScalaRomansImperative
+
+class ScalaRomansPipeline extends Romans:
+  override def toNumeral(number: Int): String = {
+    ("I" * number)
+      .replace("IIIII", "V")
+      .replace("IIII", "IV")
+      .replace("VV", "X")
+      .replace("VIV", "IX")
+      .replace("XXXXX", "L")
+      .replace("XXXX", "XL")
+      .replace("LL", "C")
+      .replace("LXL", "XC")
+      .replace("CCCCC", "D")
+      .replace("CCCC", "CD")
+      .replace("DD", "M")
+      .replace("DCD", "CM")
+      // custom edge cases
+      //.replace("CMXCIX", "IM") // 999
+      //.replace("XCIX", "IC")   // 99
+  }
+  
+  override def toInt(roman: String): Int =
+    roman
+      .replace("CM", "DCD")
+      .replace("M", "DD")
+      .replace("CD", "CCCC")
+      .replace("D", "CCCCC")
+      .replace("XC", "LXL")
+      .replace("C", "LL")
+      .replace("XL", "XXXX")
+      .replace("L", "XXXXX")
+      .replace("IX", "VIV")
+      .replace("X", "VV")
+      .replace("IV", "IIII")
+      .replace("V", "IIIII")
+      .length
+end ScalaRomansPipeline

src/main/java/JavaPlayground/JavaRomans.java

@@ -0,0 +1,32 @@
+import JavaPlayground.JavaRomans
+import ScalaPlayground.RomanNumerals.{ScalaRomansImperative, ScalaRomansPipeline}
+import org.scalatest.funsuite.AnyFunSuite
+import org.scalatest.prop.TableDrivenPropertyChecks.*
+import org.scalatest.prop.TableFor2
+
+class IntToRomanNumeralTest extends AnyFunSuite {
+  val testCases: TableFor2[Int, String] = Table(
+    ("input", "expected"),
+    (0, ""),
+    (1, "I"),
+    (4, "IV"),
+    (9, "IX"),
+    (58, "LVIII"),
+    (1999, "MCMXCIX"),
+    (2023, "MMXXIII"),
+    (1987, "MCMLXXXVII"),
+    (3999, "MMMCMXCIX"),
+  )
+
+  val javaRomans            = new JavaRomans
+  val scalaRomansPipeline   = new ScalaRomansPipeline
+  val scalaRomansImperative = new ScalaRomansImperative
+
+  testCases.foreach { case (input, expected) =>
+    test(s"Java and Scala implementations return $expected for input $input") {
+      assert(javaRomans.toNumeral(input) == expected)
+      assert(scalaRomansPipeline.toNumeral(input) == expected)
+      assert(scalaRomansImperative.toNumeral(input) == expected)
+    }
+  }
+}

src/main/java/JavaPlayground/ScalaCalculator.scala

@@ -0,0 +1,25 @@
+import ScalaPlayground.RomanNumerals.ScalaRomansPipeline
+import org.scalatest.funsuite.AnyFunSuite
+import org.scalatest.prop.TableDrivenPropertyChecks._
+
+class RomanNumeralsBenchmarkTest extends AnyFunSuite {
+  test("benchmark the performance of Roman Numerals implementations") {
+    def checkDuration(action: Int => String, input: Int, iterations: Int, message: String): Unit = {
+      val now = System.nanoTime()
+      for (_ <- 1 to iterations) action(input)
+      val elapsed = System.nanoTime() - now
+
+      println(message)
+      println(elapsed / 1_000_000 + " ms")
+    }
+
+    val input = 3999
+    val iterations = 1_000_000
+
+    val javaRomans = new JavaPlayground.JavaRomans()
+    val scalaRomans = ScalaRomansPipeline()
+
+    checkDuration(scalaRomans.toNumeral, input, iterations, "Scala Romans Imperative")
+    checkDuration(javaRomans.toNumeral, input, iterations, "Java Romans Imperative")
+  }
+}