feat(scala): initial dump

This commit includes solutions for various leetcode problems written in Scala. The problems cover a wide range of topics from data structures, dynamic programming, tree search, and more.

Author: martianoff

Diff for: .gitignore

@@ -0,0 +1 @@
+.idea

Diff for: README.md

@@ -0,0 +1,23 @@
+# LeetCode Solutions Archive
+
+Leetcode profile https://leetcode.com/u/maxmtmn/
+
+These solutions have been collected over years and might have slightly different style, which evolved over time.
+Currently, contains `Scala` solutions only.
+
+Welcome to our open-source project - a curated collection of solutions for problems posed on `LeetCode`, all written in
+the functional and object-oriented programming language, `Scala`.
+
+This project is a treasure trove for all those interested in improving their algorithmic problem-solving skills,
+developers preparing for their next coding interview, or anyone who is a lover of logic and puzzles.
+
+This repository contains numerous individual Scala files, each tailored to solve a unique LeetCode problem. The Scala
+files are conveniently named following the Leet's numbering system (`Leet<problem_number>.scala`), which makes it quite
+straightforward to find solutions to your problem of interest.
+
+Remember, the purpose of this project is not to endorse the mere copying of solutions but to learn, understand and
+internalize the logic and elegance of problem-solving in `Scala`. So, seize this opportunity to deepen your knowledge
+and become a better developer.
+
+I welcome your contributions and encourage you to submit pull requests to enhance the quality and diversity of
+solutions. Happy learning and coding!

Diff for: scala/Leet1011.scala

@@ -0,0 +1,41 @@
+
+
+object Leet1011 extends App {
+
+  object Solution {
+    def shipWithinDays(weights: Array[Int], days: Int): Int = {
+      // ans is between maxWeight and totalWeight
+      val totalWeights = weights.sum
+      var left = weights.max
+      var right = totalWeights
+      var result = totalWeights
+      while (left <= right) {
+        val mid = (left + right) / 2
+        val daysWithThisCapacity = minDaysWithCapacity(weights, mid)
+        if (daysWithThisCapacity <= days) {
+          result = result min mid
+        }
+        if (daysWithThisCapacity <= days) {
+          // we have extra capacity and can work faster
+          right = mid - 1
+        } else {
+          // not enough capacity
+          left = mid + 1
+        }
+      }
+      result
+    }
+
+    private def minDaysWithCapacity(weights: Array[Int], capacity: Int): Int = {
+      weights.foldLeft((1, 0)) {
+        // fill at the same day
+        case ((days, used), weight) if used + weight <= capacity =>
+          (days, used + weight)
+        // fill at the next day
+        case ((days, used), weight) =>
+          (days + 1, weight)
+      }._1
+    }
+  }
+
+}

Diff for: scala/Leet102.scala

@@ -0,0 +1,33 @@
+object Leet102 extends App {
+
+  import scala.collection.mutable
+
+  class TreeNode(_value: Int = 0, _left: TreeNode = null, _right: TreeNode = null) {
+    var value: Int = _value
+    var left: TreeNode = _left
+    var right: TreeNode = _right
+  }
+
+  object Solution {
+    def levelOrder(root: TreeNode): List[List[Int]] = {
+      Option(root).map {
+        n =>
+          val levels = mutable.Map.empty[Int, List[Int]].withDefaultValue(List())
+          traverse(n, levels)
+          (0 until levels.size).map(l => levels(l)).toList
+      }.getOrElse(List())
+    }
+
+    private def traverse(node: TreeNode, levels: mutable.Map[Int, List[Int]], level: Int = 0): Unit = {
+      levels(level) = node.value :: levels(level)
+      (Option(node.left), Option(node.right)) match {
+        case (None, Some(r)) => traverse(r, levels, level + 1)
+        case (Some(l), None) => traverse(l, levels, level + 1)
+        case (Some(l), Some(r)) =>
+          traverse(r, levels, level + 1)
+          traverse(l, levels, level + 1)
+        case _ =>
+      }
+    }
+  }
+}

Diff for: scala/Leet1055.scala

@@ -0,0 +1,20 @@
+import scala.collection.mutable
+
+object Leet1055 extends App {
+
+  object Solution {
+    def shortestWay(source: String, target: String): Int = {
+      if (!target.toSet.subsetOf(source.toSet)) return -1
+      Iterator.unfold((source.toList, target.toList)) {
+        // target constructed
+        case (_, Nil) => None
+        // source sequence is used, try another sequence
+        case (Nil, target) => Some(1, (source.toList, target))
+        // if matches eliminate as much as possible
+        case (sourceHead :: sourceTail, targetHead :: targetTail) if sourceHead == targetHead => Some(0, (sourceTail, targetTail))
+        // if doesn't match try next combination
+        case (_ :: sourceTail, target) => Some(0, (sourceTail, target))
+      }.sum + 1 //add one because final combination always give 1
+    }
+  }
+}

Diff for: scala/Leet1058.scala

@@ -0,0 +1,62 @@
+import scala.collection.mutable
+
+object Leet1058 extends App {
+
+  class Number(numStr: String) {
+    lazy val floor = numInt - numInt % 1000
+    lazy val ceil = if (numInt != floor) {
+      floor + 1000
+    } else {
+      floor
+    }
+    private val numInt = numStr.split('.') match {
+      case Array(a, b) => a.toInt * 1000 + b.toInt
+      case _ => throw new Exception("Invalid input")
+    }
+
+    def toInt() = {
+      numInt
+    }
+  }
+
+  class Dfs(prices: Array[Number], target: Int) {
+    private val target1000 = target * 1000
+    private val cache = mutable.Set.empty[(Int, Int, Int)]
+    private var result: Option[Int] = None
+
+    def getResult(): Option[Int] = {
+      result
+    }
+
+    def search(priceId: Int, sum: Int, diff: Int): Unit = {
+      if (result.exists(_ < diff) || sum > target1000 || cache.contains((priceId, sum, diff))) {
+        return
+      } else {
+        cache += ((priceId, sum, diff))
+        if (priceId == prices.length) {
+          if (sum == target1000) {
+            result = Some(diff)
+          }
+        } else {
+          search(priceId + 1, sum + prices(priceId).floor, diff + (prices(priceId).toInt - prices(priceId).floor).abs)
+          if (prices(priceId).floor != prices(priceId).ceil) {
+            search(priceId + 1, sum + prices(priceId).ceil, diff + (prices(priceId).toInt - prices(priceId).ceil).abs)
+          }
+        }
+      }
+
+    }
+
+    search(0, 0, 0)
+  }
+
+  object Solution {
+    def minimizeError(prices: Array[String], target: Int): String = {
+      new Dfs(prices.map(new Number(_)), target)
+        .getResult
+        .map(r => "%.3f".format(r.toDouble / 1000))
+        .getOrElse("-1")
+    }
+
+  }
+}

Diff for: scala/Leet1058a.scala

@@ -0,0 +1,56 @@
+import scala.collection.mutable
+
+object Leet1058a extends App {
+
+  import scala.collection.mutable
+
+  class Number(numStr: String) {
+    val floor = numInt - numInt % 1000
+    val ceil = if (numInt != floor) {
+      floor + 1000
+    } else {
+      floor
+    }
+    private val numInt = numStr.split('.') match {
+      case Array(a, b) => a.toInt * 1000 + b.toInt
+      case _ => throw new Exception("Invalid input")
+    }
+
+    def toInt = numInt
+  }
+
+  object Solution {
+    def minimizeError(prices: Array[String], target: Int): String = {
+      val nums = prices.map(new Number(_))
+      val minDiff = nums.map(_.floor).sum
+      val maxDiff = nums.map(_.ceil).sum
+      if (minDiff > target * 1000 || maxDiff < target * 1000) {
+        return "-1"
+      }
+      // do not include numbers where ceil operation doesn't give increment of a number
+      val ceilCosts = mutable.PriorityQueue.from(nums.collect {
+        case n if n.ceil != n.toInt => n.ceil - n.toInt
+      })(Asc)
+      var numberOfCeilRequired = (target * 1000 - minDiff) / 1000
+      var costPaidToFloor = nums.map(n => n.toInt - n.floor).sum
+      while (numberOfCeilRequired > 0) {
+        val costToCeil = ceilCosts.dequeue()
+        // since costPaidToFloor already includes floor cost for every option,
+        // and we want to do ceil instead of floor,
+        // we need to deduct the paid cost first
+        costPaidToFloor -= (1000 - costToCeil)
+        // add cost to ceil
+        costPaidToFloor += costToCeil
+        numberOfCeilRequired -= 1
+      }
+      "%.3f".format(costPaidToFloor.toDouble / 1000)
+    }
+
+    object Asc extends Ordering[Int] {
+      def compare(a: Int, b: Int) = {
+        b compare a
+      }
+    }
+
+  }
+}

Diff for: scala/Leet1062.scala

@@ -0,0 +1,14 @@
+object Leet1062 extends App {
+  object Solution {
+    def longestRepeatingSubstring(s: String): Int = {
+      (s.length - 1 to 1 by -1).foreach {
+        substrLen =>
+          s.sliding(substrLen, 1).foldLeft(Set.empty[String]) {
+            case (aggr, sliding) if aggr.contains(sliding) => return substrLen
+            case (aggr, sliding) => aggr + sliding
+          }
+      }
+      0
+    }
+  }
+}

Diff for: scala/Leet113.scala

@@ -0,0 +1,53 @@
+import scala.collection.immutable.{AbstractSeq, LinearSeq}
+
+object Leet113 extends App {
+  val tree = new TreeNode(_value = 5,
+    _left = new TreeNode(_value = 1,
+      _left = new TreeNode(_value = 3,
+        _left = null,
+        _right = null),
+      _right = null),
+    _right = new TreeNode(_value = 2,
+      _left = new TreeNode(_value = 6,
+        _left = null,
+        _right = null),
+      _right = new TreeNode(_value = 4,
+        _left = null,
+        _right = null)))
+
+  class TreeNode(_value: Int = 0, _left: TreeNode = null, _right: TreeNode = null) {
+    var value: Int = _value
+    var left: TreeNode = _left
+    var right: TreeNode = _right
+  }
+
+  object Solution {
+    def pathSum(root: TreeNode, targetSum: Int): List[List[Int]] = {
+      root match {
+        // the bottom
+        case TreeNode(None, None) if targetSum == root.value =>
+          List(List(root.value))
+        // the middle
+        case TreeNode(lOpt, rOpt) =>
+          // filter possible paths
+          List(lOpt, rOpt).collect { case Some(node) => node }.map(
+            node => pathSum(node, targetSum - root.value)
+              .map(root.value :: _)
+          ) match {
+            case Nil => List.empty[List[Int]]
+            case list => list.reduceLeft(_ ++ _)
+          }
+        // dead end
+        case _ => List.empty[List[Int]]
+      }
+    }
+  }
+
+  object TreeNode {
+    def unapply(node: TreeNode): Option[(Option[TreeNode], Option[TreeNode])] = {
+      Option(node).map(node => (Option(node.left), Option(node.right)))
+    }
+  }
+
+  println(Solution.pathSum(tree, 6))
+}

Diff for: scala/Leet1136.scala

@@ -0,0 +1,49 @@
+import scala.collection.mutable
+
+object Leet1136 extends App {
+
+  import scala.collection.mutable
+
+  object Solution {
+    def minimumSemesters(n: Int, relations: Array[Array[Int]]): Int = {
+      // build indegree map and graph
+      val indegree = mutable.Map.empty[Int, Int]
+      (1 to n).foreach {
+        v => indegree(v) = 0
+      }
+      val graph = mutable.Map.empty[Int, List[Int]].withDefaultValue(List())
+      relations.foreach {
+        case Array(from, to) =>
+          indegree(to) += 1
+          graph(from) = to :: graph(from)
+      }
+      // find starting points
+      val queue = mutable.Queue.empty[(Int, Int)]
+      indegree.foreach {
+        case (n, in) if in == 0 => queue.enqueue((n, 1))
+        case _ =>
+      }
+      // explore using topological search
+      var semesters = 0
+      val needToVisit = mutable.Set.from(1 to n)
+      while (queue.nonEmpty) {
+        queue.dequeue() match {
+          case (n, semester) =>
+            needToVisit -= n
+            if (needToVisit.isEmpty) {
+              return semester
+            }
+            graph(n).foreach {
+              dest =>
+                indegree(dest) -= 1
+                if (indegree(dest) == 0) {
+                  queue.enqueue((dest, semester + 1))
+                }
+            }
+        }
+      }
+      -1
+    }
+  }
+
+}