Improved tasks

Author: javadev

README.md

@@ -45,15 +45,16 @@ You can return the answer in any order.
 ```scala
 object Solution {
     def twoSum(nums: Array[Int], target: Int): Array[Int] = {
-        val lookup = scala.collection.mutable.Map[Int, Int]()
-        for (idx <- nums.indices) {
-            if (lookup.contains(target - nums(idx))) {
-                return Array(lookup(target - nums(idx)), idx)
-            } else {
-                lookup.addOne(nums(idx) -> idx)
-            }
+        val indiced = nums.zipWithIndex
+        val sortedStruct = indiced.sortBy(_._1)
+        var i = 0
+        var j = nums.length - 1
+        while (i < j && j > 0) {
+            if sortedStruct(j)._1 + sortedStruct(i)._1 > target then j = j - 1
+            else if sortedStruct(j)._1 + sortedStruct(i)._1 < target then i = i + 1
+            else return Array(sortedStruct(i)._2, sortedStruct(j)._2)
         }
-        Array(-1, -1)
+        return Array(-1, -1)
     }
 }
 ```

src/main/scala/g0001_0100/s0001_two_sum/readme.md

@@ -51,27 +51,32 @@ An input string is valid if:
 
 ```scala
 import scala.collection.mutable.Stack
+import scala.util.control.Breaks._
 
 object Solution {
     def isValid(s: String): Boolean = {
         val stack = Stack[Char]()
-
-        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
+        var result = true
+
+        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/s0020_valid_parentheses/readme.md

@@ -40,20 +40,21 @@ 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

src/main/scala/g0001_0100/s0041_first_missing_positive/readme.md

@@ -41,7 +41,8 @@ object Solution {
         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))
@@ -52,11 +53,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/s0045_jump_game_ii/readme.md

@@ -38,32 +38,31 @@ object Solution {
         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/s0055_jump_game/readme.md

@@ -56,11 +56,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
                 }
             }
         }
@@ -75,11 +74,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

src/main/scala/g0001_0100/s0079_word_search/readme.md

@@ -33,6 +33,8 @@ Given an array of integers `heights` representing the histogram's bar height whe
 ## Solution
 
 ```scala
+import scala.util.control.Breaks.{break, breakable}
+
 object Solution {
     def largestRectangleArea(heights: Array[Int]): Int = {
         largestArea(heights, 0, heights.length)
@@ -84,12 +86,16 @@ object Solution {
     }
 
     private def checkIfSorted(a: Array[Int], start: Int, limit: Int): Boolean = {
-        for (i <- start + 1 until limit) {
-            if (a(i) < a(i - 1)) {
-                return false
+        var sorted = true
+        breakable {
+            for (i <- start + 1 until limit) {
+                if (a(i) < a(i - 1)) {
+                    sorted = false
+                    break
+                }
             }
         }
-        true
+        sorted
     }
 
     private def maxOfThreeNums(a: Int, b: Int, c: Int): Int = {

src/main/scala/g0001_0100/s0084_largest_rectangle_in_histogram/readme.md

@@ -38,41 +38,31 @@ Return `true` if you can finish all courses. Otherwise, return `false`.
 ## Solution
 
 ```scala
-import scala.collection.mutable.ArrayBuffer
-
 object Solution {
-    val WHITE = 0
-    val GRAY = 1
-    val BLACK = 2
-
     def canFinish(numCourses: Int, prerequisites: Array[Array[Int]]): Boolean = {
-        val adj = Array.fill(numCourses)(new ArrayBuffer[Int]())
-        prerequisites.foreach { pre =>
-            adj(pre(1)).append(pre(0))
-        }
-
-        val colors = Array.fill(numCourses)(WHITE)
-        (0 until numCourses).forall { i =>
-            if (colors(i) == WHITE && adj(i).nonEmpty && hasCycle(adj, i, colors)) {
-                false
-            } else {
-                true
-            }
+        import scala.collection.mutable.{Queue, ListBuffer}
+        val indegree = Array.fill(numCourses)(0)
+        val graph = Array.fill(numCourses)(new ListBuffer[Int])
+        for (data <- prerequisites) {
+            val course = data.head
+            val prerequisiteCourse = data.last
+            indegree(course) = indegree(course) + 1
+            graph(prerequisiteCourse) += course
         }
-    }
-
-    private def hasCycle(adj: Array[ArrayBuffer[Int]], node: Int, colors: Array[Int]): Boolean = {
-        colors(node) = GRAY
-        adj(node).foreach { nei =>
-            if (colors(nei) == GRAY) {
-                return true
-            }
-            if (colors(nei) == WHITE && hasCycle(adj, nei, colors)) {
-                return true
+        val startingCourses = indegree.zipWithIndex.filter(_._1.equals(0)).map(_._2)
+        val queue = Queue[Int](startingCourses: _*)
+        var courseTaken = 0
+        while (queue.nonEmpty) {
+            val current = queue.dequeue
+            courseTaken = courseTaken + 1
+            for (neighbor <- graph(current)) {
+                indegree(neighbor) = indegree(neighbor) - 1
+                if (indegree(neighbor).equals(0)) {
+                    queue.enqueue(neighbor)
+                }
             }
         }
-        colors(node) = BLACK
-        false
+        courseTaken == numCourses
     }
 }
 ```

src/main/scala/g0201_0300/s0207_course_schedule/readme.md

@@ -44,40 +44,42 @@ import com_github_leetcode.ListNode
  */
 object Solution {
     def isPalindrome(head: ListNode): Boolean = {
-        var len = 0
-        var right = head
-
-        // Calculate the length
-        while (right != null) {
-            right = right.next
-            len += 1
+        if (head == null || head.next == null) {
+            return true
         }
-
-        // Reverse the right half of the list
-        len = len / 2
-        right = head
-        for (_ <- 0 until len) {
-            right = right.next
+        def reverseList(node: ListNode): ListNode = {
+            var prev: ListNode = null
+            var current: ListNode = node
+            while (current != null) {
+                val nextNode = current.next
+                current.next = prev
+                prev = current
+                current = nextNode
+            }
+            prev
         }
 
-        var prev: ListNode = null
-        while (right != null) {
-            val next = right.next
-            right.next = prev
-            prev = right
-            right = next
+        def findMiddle(node: ListNode): ListNode = {
+            var slow = node
+            var fast = node
+            while (fast != null && fast.next != null) {
+                slow = slow.next
+                fast = fast.next.next
+            }
+            slow
         }
-        var head2 = head
-        // Compare left half and right half
-        for (_ <- 0 until len) {
-            if (prev != null && head2.x == prev.x) {
-                head2 = head2.next
-                prev = prev.next
-            } else {
+
+        val middle = findMiddle(head)
+        var secondHalf = reverseList(middle)
+
+        var firstHalf = head
+        while (secondHalf != null) {
+            if (firstHalf.x != secondHalf.x) {
                 return false
             }
+            firstHalf = firstHalf.next
+            secondHalf = secondHalf.next
         }
-
         true
     }
 }