add scala solutions for 20 - 23

Author: HangMerlin

Diff for: May-LeetCoding-Challenge/20-Kth-Smallest-Element-In-A-BST/Kth-Smallest-Element-In-A-BST.scala

@@ -0,0 +1,15 @@
+class TreeNode(_value: Int = 0, _left: TreeNode = null, _right: TreeNode = null) {
+  var value: Int = _value
+  var left: TreeNode = _left
+  var right: TreeNode = _right
+}
+
+//recursive and iteration solution
+object Solution {
+  def kthSmallest(root: TreeNode, k: Int): Int = kthSmallestWithAcc(root, Seq())(k - 1)
+
+  def kthSmallestWithAcc(root: TreeNode, acc: Seq[Int]): Seq[Int] = {
+    if (root == null) acc
+    else kthSmallestWithAcc(root.right, kthSmallestWithAcc(root.left, acc) ++ Seq(root.value))
+  }
+}

Diff for: May-LeetCoding-Challenge/21-Count-Square-Submatrices-With-All-Ones/Count-Square-Submatrices-With-All-Ones.scala

@@ -0,0 +1,42 @@
+//brute force solution
+object Solution {
+  def countSquares(matrix: Array[Array[Int]]): Int = {
+    val maxX = matrix(0).length
+    val maxY = matrix.length
+    val maxSide = maxX max maxY
+    val list = for (side <- 0 until maxSide; x <- 0 until (maxX - side); y <- 0 until (maxY - side); if isAllOne(matrix, x, y, side)) yield 1
+    list.size
+  }
+
+  def isAllOne(matrix: Array[Array[Int]], startX: Int, startY: Int, side: Int): Boolean =
+    !(startX to startX + side).exists(x => (startY to startY + side).exists(y => matrix(y)(x) == 0))
+
+}
+
+//optimized solution O(x * y * 2)
+object Solution2 {
+  def countSquares(matrix: Array[Array[Int]]): Int = {
+    val maxX = matrix(0).length
+    val maxY = matrix.length
+    val res = Array.fill(maxY)(Array.fill(maxX)(0))
+    for (x <- 0 until maxX; y <- 0 until maxY; if matrix(y)(x) == 1) {
+      res(y)(x) = if (x != 0 && y != 0) ((res(y - 1)(x) min res(y - 1)(x - 1)) min res(y)(x - 1)) + 1 else 1
+    }
+    res.foldLeft(0)((acc, rang) => acc + rang.sum)
+  }
+}
+
+//optimized solution+ O(x * y)
+object Solution3 {
+  def countSquares(matrix: Array[Array[Int]]): Int = {
+    val maxX = matrix(0).length
+    val maxY = matrix.length
+    val res = Array.fill(maxY)(Array.fill(maxX)(0))
+    var total = 0
+    for (x <- 0 until maxX; y <- 0 until maxY; if matrix(y)(x) == 1) {
+      res(y)(x) = if (x != 0 && y != 0) ((res(y - 1)(x) min res(y - 1)(x - 1)) min res(y)(x - 1)) + 1 else 1
+      total += res(y)(x)
+    }
+    total
+  }
+}

Diff for: May-LeetCoding-Challenge/22-Sort-Characters-By-Frequency/Sort-Characters-By-Frequency.scala

@@ -0,0 +1,4 @@
+//easiest solution but maybe not the fastest way
+object Solution {
+  def frequencySort(s: String): String = s.groupBy(c => c).toSeq.sortBy(-_._2.length).foldLeft("")((acc, t) => acc + t._2)
+}

Diff for: May-LeetCoding-Challenge/23-Interval-List-Intersections/Interval-List-Intersections.scala

@@ -0,0 +1,18 @@
+object Solution {
+  def intervalIntersection(A: Array[Array[Int]], B: Array[Array[Int]]): Array[Array[Int]] = {
+    import scala.collection.mutable
+    var res = mutable.Seq.empty[Array[Int]]
+    var indexA = 0
+    var indexB = 0
+    while (indexA < A.length && indexB < B.length) {
+      val (intAStart, intAEnd) = (A(indexA)(0), A(indexA)(1))
+      val (intBStart, intBEnd) = (B(indexB)(0), B(indexB)(1))
+      val start = intAStart max intBStart
+      val end = intAEnd min intBEnd
+      if (intAEnd >= intBEnd) indexB += 1
+      if (intBEnd >= intAEnd) indexA += 1
+      if (end >= start) res = res :+ Array(start, end)
+    }
+    res.toArray
+  }
+}