Updated readme

Author: javadev

README.md

@@ -0,0 +1,60 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Scala/LeetCode-in-Scala?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala)
+[![](https://img.shields.io/github/forks/LeetCode-in-Scala/LeetCode-in-Scala?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala/fork)
+
+## 42\. Trapping Rain Water
+
+Hard
+
+Given `n` non-negative integers representing an elevation map where the width of each bar is `1`, compute how much water it can trap after raining.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/10/22/rainwatertrap.png)
+
+**Input:** height = [0,1,0,2,1,0,1,3,2,1,2,1]
+
+**Output:** 6
+
+**Explanation:** The above elevation map (black section) is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. 
+
+**Example 2:**
+
+**Input:** height = [4,2,0,3,2,5]
+
+**Output:** 9 
+
+**Constraints:**
+
+*   `n == height.length`
+*   <code>1 <= n <= 2 * 10<sup>4</sup></code>
+*   <code>0 <= height[i] <= 10<sup>5</sup></code>
+
+## Solution
+
+```scala
+object Solution {
+    def trap(height: Array[Int]): Int = {
+        var left = 0
+        var right = height.length - 1
+        var result = 0
+        var lowerWall = 0
+
+        while (left < right) {
+            val leftValue = height(left)
+            val rightValue = height(right)
+
+            if (leftValue < rightValue) {
+                lowerWall = Math.max(leftValue, lowerWall)
+                result += lowerWall - leftValue
+                left += 1
+            } else {
+                lowerWall = Math.max(rightValue, lowerWall)
+                result += lowerWall - rightValue
+                right -= 1
+            }
+        }
+
+        result
+    }
+}
+```

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

@@ -0,0 +1,62 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Scala/LeetCode-in-Scala?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala)
+[![](https://img.shields.io/github/forks/LeetCode-in-Scala/LeetCode-in-Scala?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala/fork)
+
+## 45\. Jump Game II
+
+Medium
+
+Given an array of non-negative integers `nums`, you are initially positioned at the first index of the array.
+
+Each element in the array represents your maximum jump length at that position.
+
+Your goal is to reach the last index in the minimum number of jumps.
+
+You can assume that you can always reach the last index.
+
+**Example 1:**
+
+**Input:** nums = [2,3,1,1,4]
+
+**Output:** 2
+
+**Explanation:** The minimum number of jumps to reach the last index is 2. Jump 1 step from index 0 to 1, then 3 steps to the last index. 
+
+**Example 2:**
+
+**Input:** nums = [2,3,0,1,4]
+
+**Output:** 2 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   `0 <= nums[i] <= 1000`
+
+## Solution
+
+```scala
+object Solution {
+    def jump(nums: Array[Int]): Int = {
+        var length = 0
+        var maxLength = 0
+        var minJump = 0
+
+        for (i <- 0 until nums.length - 1) {
+            length -= 1
+            maxLength -= 1
+            maxLength = math.max(maxLength, nums(i))
+
+            if (length <= 0) {
+                length = maxLength
+                minJump += 1
+            }
+
+            if (length >= nums.length - i - 1) {
+                return minJump
+            }
+        }
+
+        minJump
+    }
+}
+```

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

@@ -0,0 +1,67 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Scala/LeetCode-in-Scala?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala)
+[![](https://img.shields.io/github/forks/LeetCode-in-Scala/LeetCode-in-Scala?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala/fork)
+
+## 46\. Permutations
+
+Medium
+
+Given an array `nums` of distinct integers, return _all the possible permutations_. You can return the answer in **any order**.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] 
+
+**Example 2:**
+
+**Input:** nums = [0,1]
+
+**Output:** [[0,1],[1,0]] 
+
+**Example 3:**
+
+**Input:** nums = [1]
+
+**Output:** [[1]] 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 6`
+*   `-10 <= nums[i] <= 10`
+*   All the integers of `nums` are **unique**.
+
+## Solution
+
+```scala
+object Solution {
+    def permute(nums: Array[Int]): List[List[Int]] = {
+        if (nums == null || nums.isEmpty) {
+            return List()
+        }
+
+        val finalResult = new scala.collection.mutable.ListBuffer[List[Int]]()
+        val used = Array.fill[Boolean](nums.length)(false)
+
+        def permuteRecur(currResult: scala.collection.mutable.ListBuffer[Int]): Unit = {
+            if (currResult.size == nums.length) {
+                finalResult += currResult.toList
+                return
+            }
+
+            for (i <- nums.indices) {
+                if (!used(i)) {
+                    currResult += nums(i)
+                    used(i) = true
+                    permuteRecur(currResult)
+                    used(i) = false
+                    currResult.remove(currResult.size - 1)
+                }
+            }
+        }
+
+        permuteRecur(new scala.collection.mutable.ListBuffer[Int]())
+        finalResult.toList
+    }
+}
+```

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

@@ -0,0 +1,70 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Scala/LeetCode-in-Scala?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala)
+[![](https://img.shields.io/github/forks/LeetCode-in-Scala/LeetCode-in-Scala?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala/fork)
+
+## 48\. Rotate Image
+
+Medium
+
+You are given an `n x n` 2D `matrix` representing an image, rotate the image by **90** degrees (clockwise).
+
+You have to rotate the image [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm), which means you have to modify the input 2D matrix directly. **DO NOT** allocate another 2D matrix and do the rotation.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/08/28/mat1.jpg)
+
+**Input:** matrix = \[\[1,2,3],[4,5,6],[7,8,9]]
+
+**Output:** [[7,4,1],[8,5,2],[9,6,3]] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/08/28/mat2.jpg)
+
+**Input:** matrix = \[\[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
+
+**Output:** [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]] 
+
+**Example 3:**
+
+**Input:** matrix = \[\[1]]
+
+**Output:** [[1]] 
+
+**Example 4:**
+
+**Input:** matrix = \[\[1,2],[3,4]]
+
+**Output:** [[3,1],[4,2]] 
+
+**Constraints:**
+
+*   `matrix.length == n`
+*   `matrix[i].length == n`
+*   `1 <= n <= 20`
+*   `-1000 <= matrix[i][j] <= 1000`
+
+## Solution
+
+```scala
+object Solution {
+    def rotate(matrix: Array[Array[Int]]): Unit = {
+        val n = matrix.length
+
+        for (i <- 0 until n / 2) {
+            for (j <- i until n - i - 1) {
+                val positions = Array(
+                    (i, j), (j, n - 1 - i), (n - 1 - i, n - 1 - j), (n - 1 - j, i)
+                )
+                var temp = matrix(positions(0)._1)(positions(0)._2)
+                for (k <- 1 until positions.length) {
+                    val nextTemp = matrix(positions(k)._1)(positions(k)._2)
+                    matrix(positions(k)._1)(positions(k)._2) = temp
+                    temp = nextTemp
+                }
+                matrix(positions(0)._1)(positions(0)._2) = temp
+            }
+        }
+    }
+}
+```

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

@@ -0,0 +1,55 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Scala/LeetCode-in-Scala?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala)
+[![](https://img.shields.io/github/forks/LeetCode-in-Scala/LeetCode-in-Scala?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala/fork)
+
+## 49\. Group Anagrams
+
+Medium
+
+Given an array of strings `strs`, group **the anagrams** together. You can return the answer in **any order**.
+
+An **Anagram** is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.
+
+**Example 1:**
+
+**Input:** strs = ["eat","tea","tan","ate","nat","bat"]
+
+**Output:** [["bat"],["nat","tan"],["ate","eat","tea"]] 
+
+**Example 2:**
+
+**Input:** strs = [""]
+
+**Output:** [[""]] 
+
+**Example 3:**
+
+**Input:** strs = ["a"]
+
+**Output:** [["a"]] 
+
+**Constraints:**
+
+*   <code>1 <= strs.length <= 10<sup>4</sup></code>
+*   `0 <= strs[i].length <= 100`
+*   `strs[i]` consists of lowercase English letters.
+
+## Solution
+
+```scala
+import scala.collection.mutable.{ArrayBuffer, Map}
+
+object Solution {
+    def groupAnagrams(strs: Array[String]): List[List[String]] = {
+        val hm = Map[String, ArrayBuffer[String]]()
+
+        for (s <- strs) {
+            val ch = s.toCharArray
+            ch.sortInPlace()
+            val temp = new String(ch)
+            hm.getOrElseUpdate(temp, ArrayBuffer.empty[String]) += s
+        }
+
+        hm.values.map(_.toList).toList
+    }
+}
+```

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

@@ -0,0 +1,72 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Scala/LeetCode-in-Scala?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala)
+[![](https://img.shields.io/github/forks/LeetCode-in-Scala/LeetCode-in-Scala?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala/fork)
+
+## 51\. N-Queens
+
+Hard
+
+The **n-queens** puzzle is the problem of placing `n` queens on an `n x n` chessboard such that no two queens attack each other.
+
+Given an integer `n`, return _all distinct solutions to the **n-queens puzzle**_. You may return the answer in **any order**.
+
+Each solution contains a distinct board configuration of the n-queens' placement, where `'Q'` and `'.'` both indicate a queen and an empty space, respectively.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/queens.jpg)
+
+**Input:** n = 4
+
+**Output:** [[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
+
+**Explanation:** There exist two distinct solutions to the 4-queens puzzle as shown above 
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** [["Q"]] 
+
+**Constraints:**
+
+*   `1 <= n <= 9`
+
+## Solution
+
+```scala
+object Solution {
+    def solveNQueens(n: Int): List[List[String]] = {
+        val rst = scala.collection.mutable.ListBuffer[List[String]]()
+        dfs(n, List[Int](), rst)
+        rst.toList
+    }
+
+    @SuppressWarnings(Array("scala:S3776"))
+    private def dfs(n: Int, oneSol: List[Int], rst: scala.collection.mutable.ListBuffer[List[String]]): Unit = {
+        if (oneSol.length == n) {
+            val line = for (idx <- oneSol) yield ("." * idx + "Q" + "." * (n - idx - 1))
+            rst += line
+            return
+        }
+        for (col <- 0 until n) {
+            if (!oneSol.contains(col)) {
+                var i = oneSol.length - 1
+                var j = col - 1
+                var k = col + 1
+                var continue = true
+                while (continue && i >= 0 && (j >= 0 || k < n)) {
+                    if (oneSol(i) == j || oneSol(i) == k) {
+                        continue = false
+                    }
+                    i -= 1
+                    j -= 1
+                    k += 1
+                }
+                if (continue) {
+                    dfs(n, oneSol :+ col, rst)
+                }
+            }
+        }
+    }
+}
+```