Improved tasks 20, 41, 45, 55, 79

Author: ThanhNIT

src/main/scala/g0001_0100/s0020_valid_parentheses/Solution.scala

@@ -2,29 +2,35 @@ package g0001_0100.s0020_valid_parentheses
 
 // #Easy #Top_100_Liked_Questions #Top_Interview_Questions #String #Stack
 // #Data_Structure_I_Day_9_Stack_Queue #Udemy_Strings #Big_O_Time_O(n)_Space_O(n)
-// #2023_10_29_Time_449_ms_(65.58%)_Space_56.6_MB_(22.33%)
+// #2024_06_01_Time_587_ms_(69.29%)_Space_58.3_MB_(60.63%)
 
 import scala.collection.mutable.Stack
+import scala.util.control.Breaks._
 
 object Solution {
     def isValid(s: String): Boolean = {
         val stack = Stack[Char]()
+        var result = true
 
-        for (i <- 0 until s.length) {
-            val c = s.charAt(i)
-            if (c == '(' || c == '[' || c == '{') {
-                stack.push(c)
-            } else if (c == ')' && stack.nonEmpty && stack.top == '(') {
-                stack.pop()
-            } else if (c == '}' && stack.nonEmpty && stack.top == '{') {
-                stack.pop()
-            } else if (c == ']' && stack.nonEmpty && stack.top == '[') {
-                stack.pop()
-            } else {
-                return false
+        breakable {
+            for (i <- 0 until s.length) {
+                val c = s.charAt(i)
+                if (c == '(' || c == '[' || c == '{') {
+                    stack.push(c)
+                } else if (c == ')' && stack.nonEmpty && stack.top == '(') {
+                    stack.pop()
+                } else if (c == '}' && stack.nonEmpty && stack.top == '{') {
+                    stack.pop()
+                } else if (c == ']' && stack.nonEmpty && stack.top == '[') {
+                    stack.pop()
+                } else {
+                    result = false
+                    break()
+                }
             }
         }
 
-        stack.isEmpty
+        result && stack.isEmpty
     }
 }
+

src/main/scala/g0001_0100/s0041_first_missing_positive/Solution.scala

@@ -1,27 +1,28 @@
 package g0001_0100.s0041_first_missing_positive
 
 // #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Array #Hash_Table #Udemy_Arrays
-// #Big_O_Time_O(n)_Space_O(n) #2023_10_30_Time_650_ms_(100.00%)_Space_78.5_MB_(100.00%)
+// #Big_O_Time_O(n)_Space_O(n) #2024_06_01_Time_912_ms_(84.21%)_Space_71.6_MB_(100.00%)
 
 import scala.annotation.tailrec
 
 object Solution {
     def firstMissingPositive(nums: Array[Int]): Int = {
         for (i <- nums.indices) {
-            if (nums(i) <= 0 || nums(i) > nums.length || nums(i) == i + 1) {
-                // Continue the loop
-            } else {
+            if (nums(i) > 0 && nums(i) < nums.length && nums(i) != i + 1) {
                 dfs(nums, nums(i))
             }
         }
 
-        for (i <- nums.indices) {
+        var result = nums.length + 1
+        var found = false
+        for (i <- nums.indices if !found) {
             if (nums(i) != i + 1) {
-                return i + 1
+                result = i + 1
+                found = true
             }
         }
 
-        nums.length + 1
+        result
     }
 
     @tailrec
@@ -34,3 +35,4 @@ object Solution {
         dfs(nums, temp)
     }
 }
+

src/main/scala/g0001_0100/s0045_jump_game_ii/Solution.scala

@@ -2,15 +2,16 @@ package g0001_0100.s0045_jump_game_ii
 
 // #Medium #Top_100_Liked_Questions #Array #Dynamic_Programming #Greedy
 // #Algorithm_II_Day_13_Dynamic_Programming #Dynamic_Programming_I_Day_4
-// #Big_O_Time_O(n)_Space_O(1) #2023_10_31_Time_510_ms_(88.52%)_Space_56_MB_(65.57%)
+// #Big_O_Time_O(n)_Space_O(1) #2024_06_01_Time_653_ms_(83.87%)_Space_58.6_MB_(87.10%)
 
 object Solution {
     def jump(nums: Array[Int]): Int = {
         var length = 0
         var maxLength = 0
         var minJump = 0
 
-        for (i <- 0 until nums.length - 1) {
+        var result = -1
+        for (i <- 0 until nums.length - 1 if result == -1) {
             length -= 1
             maxLength -= 1
             maxLength = math.max(maxLength, nums(i))
@@ -21,10 +22,11 @@ object Solution {
             }
 
             if (length >= nums.length - i - 1) {
-                return minJump
+                result = minJump
             }
         }
 
-        minJump
+        if (result == -1) minJump else result
     }
 }
+

src/main/scala/g0001_0100/s0055_jump_game/Solution.scala

@@ -2,38 +2,38 @@ package g0001_0100.s0055_jump_game
 
 // #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Dynamic_Programming #Greedy
 // #Algorithm_II_Day_12_Dynamic_Programming #Dynamic_Programming_I_Day_4 #Udemy_Arrays
-// #Big_O_Time_O(n)_Space_O(1) #2023_10_31_Time_622_ms_(88.31%)_Space_56.9_MB_(44.16%)
+// #Big_O_Time_O(n)_Space_O(1) #2024_06_01_Time_769_ms_(79.03%)_Space_59.8_MB_(50.00%)
 
 object Solution {
     def canJump(nums: Array[Int]): Boolean = {
         val sz = nums.length
         // We set tmp to 1 so it won't break on the first iteration
         var tmp = 1
+        var result = true // Variable to store the result
 
-        for (i <- 0 until sz) {
+        for (i <- 0 until sz if result) {
             // We always deduct tmp for every iteration
             tmp -= 1
             if (tmp < 0) {
                 // If from the previous iteration tmp is already 0, it will be < 0 here,
                 // leading to a false value
-                return false
-            }
-            // We get the maximum value because this value is supposed to be our iterator. If both values are 0,
-            // then the next iteration will return false.
-            // We can stop the whole iteration with this condition. Without this condition, the code runs in 2ms (79.6%).
-            // Adding this condition improves the performance to 1ms (100%)
-            // because if the test case jump value is quite large, instead of just iterating, we can
-            // just check using this condition.
-            // Example: [10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] -> we can just jump to the end without iterating the whole array.
-            tmp = math.max(tmp, nums(i))
-            if (i + tmp >= sz - 1) {
-                return true
+                result = false
+            } else {
+                // We get the maximum value because this value is supposed to be our iterator. If both values are 0,
+                // then the next iteration will return false.
+                // We can stop the whole iteration with this condition. Without this condition, the code runs in 2ms (79.6%).
+                // Adding this condition improves the performance to 1ms (100%)
+                // because if the test case jump value is quite large, instead of just iterating, we can
+                // just check using this condition.
+                // Example: [10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] -> we can just jump to the end without iterating the whole array.
+                tmp = math.max(tmp, nums(i))
+                if (i + tmp >= sz - 1) {
+                    result = true
+                }
             }
         }
-        // We can just return true at the end because if tmp is 0 on the previous
-        // iteration,
-        // even though the next iteration's index is the last one, it will return false under the
-        // tmp < 0 condition.
-        true
+
+        result
     }
 }
+

src/main/scala/g0001_0100/s0079_word_search/Solution.scala

@@ -2,7 +2,7 @@ package g0001_0100.s0079_word_search
 
 // #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Matrix #Backtracking
 // #Algorithm_II_Day_11_Recursion_Backtracking #Big_O_Time_O(4^(m*n))_Space_O(m*n)
-// #2023_11_02_Time_783_ms_(94.87%)_Space_54.9_MB_(100.00%)
+// #2024_06_01_Time_848_ms_(74.19%)_Space_59.5_MB_(66.67%)
 
 object Solution {
     private val directions = Array(Array(-1, 0), Array(1, 0), Array(0, -1), Array(0, 1))
@@ -14,11 +14,10 @@ object Solution {
         numRows = board.length
         numCols = board(0).length
         var result = false
-        for (row <- 0 until numRows) {
-            for (col <- 0 until numCols) {
+        for (row <- 0 until numRows if !result) {
+            for (col <- 0 until numCols if !result) {
                 if (board(row)(col) == word(0)) {
                     result = backTracking(board, row, col, word, 0)
-                    if (result) return true
                 }
             }
         }
@@ -33,11 +32,10 @@ object Solution {
         val originalValue = board(row)(col)
         board(row)(col) = '0'
         var output = false
-        for (dir <- directions) {
+        for (dir <- directions if !output) {
             val newRow = row + dir(0)
             val newCol = col + dir(1)
             output = backTracking(board, newRow, newCol, word, index + 1)
-            if (output) return true
         }
         board(row)(col) = originalValue
         output