scala solutions for 72, 97, 215, 322, 394, 485, 509, 746

Author: Imtiaz Ahmed

.gitignore

@@ -1 +1,3 @@
-.DS_Store
+.DS_Store
+.metals
+.vscode

scala/0072-edit-distance.scala

@@ -0,0 +1,16 @@
+object Solution {
+    def minDistance(word1: String, word2: String): Int = {
+        var minDisArr = Array.ofDim[Int](word1.size+2, word2.size+2)
+        for(i<- 0 to word1.size; j<- 0 to word2.size){
+            if(i == 0 || j == 0) minDisArr(i)(j) = i + j
+
+            else if (word1(i-1).equals(word2(j-1)))
+                minDisArr(i)(j) = minDisArr(i-1)(j-1)
+            
+            else 
+                minDisArr(i)(j) = 1 + (minDisArr(i - 1)(j - 1) min minDisArr(i)(j - 1) min minDisArr(i - 1)(j))
+
+        }
+        minDisArr(word1.size)(word2.size)
+    }
+}

scala/0097-interleaving-string.scala

@@ -0,0 +1,21 @@
+object Solution {
+    def isInterleave(s1: String, s2: String, s3: String): Boolean = {
+        val c1 = s1.toCharArray()
+        val c2 = s2.toCharArray()
+        val c3 = s3.toCharArray()
+        val m = s1.length()
+        val n = s2.length()
+        if(m + n != s3.length()) false;
+        else dfs(c1, c2, c3, 0, 0, 0, Array.ofDim[Boolean](m+1, n+1))
+    }
+
+    def dfs(c1: Array[Char], c2: Array[Char], c3: Array[Char], i:Int, j:Int, k:Int, invalid: Array[Array[Boolean]]): Boolean = {
+        if(invalid(i)(j)) return false
+        if(k == c3.length) return true
+        val valid =
+            i < c1.length && c1(i) == c3(k) && dfs(c1, c2, c3, i + 1, j, k + 1, invalid) ||
+                j < c2.length && c2(j) == c3(k) && dfs(c1, c2, c3, i, j + 1, k + 1, invalid)
+        if(!valid) invalid(i)(j) = true
+        valid
+    }
+}

scala/0215-kth-largest-element-in-an-array.scala

@@ -0,0 +1,15 @@
+import scala.collection.mutable.PriorityQueue
+
+object Solution {
+    def findKthLargest(nums: Array[Int], k: Int): Int = {
+        val pq = PriorityQueue.empty(Ordering[Int].reverse)
+        for(i <- 0 until nums.size){
+            if (i < k) pq.enqueue(nums(i))
+            else {
+                pq.enqueue(nums(i))
+                pq.dequeue()
+            }
+        }
+        pq.dequeue()
+    }
+}

scala/0322-coin-change.scala

@@ -0,0 +1,17 @@
+object Solution {
+    def coinChange(coins: Array[Int], amount: Int): Int = {
+        var dp: Array[Int] = List.fill[Int](amount+5)(amount+1).toArray
+        dp(0) = 0
+        for(i <- 1 to amount)
+        {
+            for(j <- 0 until coins.size)
+            {
+                if(coins(j) <= i)
+                {
+                    dp(i) = dp(i) min (dp(i - coins(j)) + 1)
+                }
+            }
+        }
+        if(dp(amount) > amount ) -1 else dp(amount);
+    }
+}

scala/0394-decode-string.scala

@@ -0,0 +1,29 @@
+object Solution {
+    
+    def decodeString(s: String): String = {
+        val (str, res) = decodeStringRecursive(s, 0)
+        str
+    }
+
+    def decodeStringRecursive(input: String, start: Int): (String, Int) = {
+        val result = new StringBuilder()
+        var i = start
+        while(i < input.length){
+            input(i) match {
+                case x if x>= '0' && x<='9' =>
+                    val currNum = input.substring(i, input.indexOf('[', i)).toInt
+                    val (str, maxI) = decodeStringRecursive(input, input.indexOf('[', i)+1)
+                    i = maxI
+                    result.append(str * currNum)
+                case x if x >= 'a' && x <= 'z' =>
+                    (result.append(x), i)
+                case ']' =>
+                    return (result.toString, i)
+                case _ =>
+            }
+            i+=1
+        }
+        (result.toString, i)
+    }
+
+}

scala/0485-max-consecutive-ones.scala

@@ -0,0 +1,4 @@
+object Solution {
+    def findMaxConsecutiveOnes(nums: Array[Int]): Int =
+        nums.scanLeft(0)((m, x) => if (x == 0) 0 else m + 1).max
+}

scala/0509-fibonacci-number.scala

@@ -0,0 +1,17 @@
+object Solution {
+    var gen: Boolean = false;
+    var fibonacci = List(0,1)
+    def fib(n: Int): Int = {
+        generate
+        fibonacci(n)
+    }
+    
+    def generate = {
+        if(!gen){
+            gen = true
+            List.range(2, 31).map(x =>
+                fibonacci = fibonacci :+ fibonacci(x-1) + fibonacci(x-2)
+            )
+        }
+    }
+}

scala/0746-min-cost-climbing-stairs.scala

@@ -0,0 +1,17 @@
+object Solution {
+    def minCostClimbingStairs(cost: Array[Int]): Int = {
+        val n = cost.length
+        var first = cost(0)
+        var second = cost(1)
+        if (n<=2)
+            first min second
+        else {
+            for ( i <- 2 until n) {
+                val curr = cost(i) + (first min second)
+                first = second
+                second = curr
+            }
+            first min second
+        }
+    }
+}