Added tasks 46, 48, 49, 51.

Author: ThanhNIT

src/main/kotlin/g0001_0100/s0046_permutations/Solution.kt

@@ -0,0 +1,31 @@
+package g0001_0100.s0046_permutations
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Backtracking
+// #Algorithm_I_Day_11_Recursion_Backtracking #Level_2_Day_20_Brute_Force/Backtracking
+// #Udemy_Backtracking/Recursion #2022_08_28_Time_299_ms_(80.72%)_Space_39.8_MB_(85.67%)
+
+class Solution {
+    fun permute(nums: IntArray): List<List<Int>> {
+        var result = mutableListOf<MutableList<Int>>()
+        val subResult = mutableListOf<Int>()
+        subResult.add(nums[0])
+        result.add(subResult)
+        for (i in 1 until nums.size) {
+            result = insert(nums[i], result)
+        }
+        return result
+    }
+
+    private fun insert(n: Int, arr: MutableList<MutableList<Int>>): MutableList<MutableList<Int>> {
+        val result = mutableListOf<MutableList<Int>>()
+        arr.forEach { p ->
+            for (i in 0..p.size) {
+                val subResult = mutableListOf<Int>()
+                subResult.addAll(p)
+                subResult.add(i, n)
+                result.add(subResult)
+            }
+        }
+        return result
+    }
+}

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

@@ -0,0 +1,29 @@
+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**.

src/main/kotlin/g0001_0100/s0048_rotate_image/Solution.kt

@@ -0,0 +1,58 @@
+package g0001_0100.s0048_rotate_image
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Math #Matrix
+// #Data_Structure_II_Day_3_Array #Programming_Skills_II_Day_7 #Udemy_2D_Arrays/Matrix
+// #2022_08_28_Time_197_ms_(89.14%)_Space_35.5_MB_(83.90%)
+
+class Solution {
+    fun rotate(matrix: Array<IntArray>) {
+        val q = Queue()
+        var l = 0
+        var r = matrix.size - 1
+        var u = 0
+        var d = matrix.size - 1
+        while (true) {
+            if (l >= r) {
+                break
+            }
+            q.initialize()
+            for (i in l until r) {
+                q.enq(matrix[u][i])
+            }
+            for (i in u until d) {
+                q.enq(matrix[i][r])
+                matrix[i][r] = q.deq()
+            }
+            for (i in r downTo l + 1) {
+                q.enq(matrix[d][i])
+                matrix[d][i] = q.deq()
+            }
+            for (i in d downTo u + 1) {
+                q.enq(matrix[i][l])
+                matrix[i][l] = q.deq()
+            }
+            for (i in l until r) {
+                matrix[u][i] = q.deq()
+            }
+            l += 1
+            r -= 1
+            u += 1
+            d -= 1
+        }
+    }
+
+    class Queue {
+        var queue = MutableList(0) { 0 }
+        fun initialize() {
+            this.queue = MutableList(0) { 0 }
+        }
+        fun enq(i: Int) {
+            this.queue.add(i)
+        }
+        fun deq(): Int {
+            val r = this.queue[0]
+            this.queue.removeAt(0)
+            return r
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+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]]
+
+**Constraints:**
+
+*   `n == matrix.length == matrix[i].length`
+*   `1 <= n <= 20`
+*   `-1000 <= matrix[i][j] <= 1000`

src/main/kotlin/g0001_0100/s0049_group_anagrams/Solution.kt

@@ -0,0 +1,36 @@
+package g0001_0100.s0049_group_anagrams
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #String #Hash_Table #Sorting
+// #Data_Structure_II_Day_8_String #Programming_Skills_II_Day_11 #Udemy_Strings
+// #2022_08_28_Time_554_ms_(82.47%)_Space_74.6_MB_(66.07%)
+
+class Solution {
+    fun groupAnagrams(strs: Array<String>): List<List<String>> {
+        if (strs.isEmpty()) {
+            return emptyList()
+        }
+
+        val hashMap = hashMapOf<String, MutableList<String>>()
+
+        for (i in strs.indices) {
+            val charArray = strs[i].toCharArray()
+            charArray.sort()
+            val sortedWord = String(charArray)
+            if (hashMap.containsKey(sortedWord)) {
+                hashMap[sortedWord]?.let {
+                    it.add(strs[i])
+                    hashMap[sortedWord] = it
+                }
+            } else {
+                val list = mutableListOf<String>()
+                list.add(strs[i])
+                hashMap[sortedWord] = list
+            }
+        }
+        val list = mutableListOf<List<String>>()
+        hashMap.values.forEach {
+            list.add(it)
+        }
+        return list
+    }
+}

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

@@ -0,0 +1,31 @@
+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.

src/main/kotlin/g0001_0100/s0051_n_queens/Solution.kt

@@ -0,0 +1,55 @@
+package g0001_0100.s0051_n_queens
+
+// #Hard #Top_100_Liked_Questions #Array #Backtracking
+// #2022_08_28_Time_280_ms_(88.35%)_Space_41.3_MB_(81.55%)
+
+class Solution {
+    fun solveNQueens(n: Int): List<List<String>> {
+        val result = mutableListOf<List<String>>()
+        val board = Array(n) { CharArray(n) { '.' } }
+        // check only top rows and cols
+        fun isValid(row: Int, col: Int): Boolean {
+            for (i in 0 until row) {
+                if (board[i][col] == 'Q')
+                    return false
+            }
+            // top right
+            var (i, j) = row - 1 to col + 1
+            while (i >= 0 && j < n) {
+                if (board[i--][j++] == 'Q')
+                    return false
+            }
+            // top left
+            i = row - 1
+            j = col - 1
+            while (i >= 0 && j >= 0) {
+                if (board[i--][j--] == 'Q') {
+                    return false
+                }
+            }
+            return true
+        }
+
+        fun construct() {
+            val list = mutableListOf<String>()
+            for (row in board) list.add(String(row))
+            result.add(list)
+        }
+
+        fun backtrack(row: Int) {
+            if (row == n) {
+                construct()
+                return
+            }
+            for (col in 0 until n) {
+                if (isValid(row, col)) {
+                    board[row][col] = 'Q'
+                    backtrack(row + 1)
+                    board[row][col] = '.'
+                }
+            }
+        }
+        backtrack(0)
+        return result
+    }
+}

src/main/kotlin/g0001_0100/s0051_n_queens/readme.md

@@ -0,0 +1,29 @@
+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`

src/test/kotlin/g0001_0100/s0046_permutations/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0001_0100.s0046_permutations
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun permute() {
+        assertThat(Solution().permute(intArrayOf(1, 2, 3)), equalTo(arrayOf(intArrayOf(3, 2, 1).toList(), intArrayOf(2, 3, 1).toList(), intArrayOf(2, 1, 3).toList(), intArrayOf(3, 1, 2).toList(), intArrayOf(1, 3, 2).toList(), intArrayOf(1, 2, 3).toList()).toList()))
+    }
+
+    @Test
+    fun permute2() {
+        assertThat(Solution().permute(intArrayOf(0, 1)), equalTo(arrayOf(intArrayOf(1, 0).toList(), intArrayOf(0, 1).toList()).toList()))
+    }
+
+    @Test
+    fun permute3() {
+        assertThat(Solution().permute(intArrayOf(1)), equalTo(arrayOf(intArrayOf(1).toList()).toList()))
+    }
+}

src/test/kotlin/g0001_0100/s0048_rotate_image/SolutionTest.kt

@@ -0,0 +1,23 @@
+package g0001_0100.s0048_rotate_image
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun rotate() {
+        var matrix = arrayOf(intArrayOf(1, 2, 3), intArrayOf(4, 5, 6), intArrayOf(7, 8, 9))
+        var expected = arrayOf(intArrayOf(7, 4, 1).toTypedArray(), intArrayOf(8, 5, 2).toTypedArray(), intArrayOf(9, 6, 3).toTypedArray())
+        Solution().rotate(matrix)
+        assertThat(matrix, equalTo(expected))
+    }
+
+    @Test
+    fun rotate2() {
+        var matrix = arrayOf(intArrayOf(5, 1, 9, 11), intArrayOf(2, 4, 8, 10), intArrayOf(13, 3, 6, 7), intArrayOf(15, 14, 12, 16))
+        var expected = arrayOf(intArrayOf(15, 13, 2, 5).toTypedArray(), intArrayOf(14, 3, 4, 1).toTypedArray(), intArrayOf(12, 6, 8, 9).toTypedArray(), intArrayOf(16, 7, 10, 11).toTypedArray())
+        Solution().rotate(matrix)
+        assertThat(matrix, equalTo(expected))
+    }
+}

src/test/kotlin/g0001_0100/s0049_group_anagrams/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0001_0100.s0049_group_anagrams
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun groupAnagrams() {
+        assertThat(Solution().groupAnagrams(arrayOf("eat", "tea", "tan", "ate", "nat", "bat")), equalTo(arrayOf(arrayOf("eat", "tea", "ate").toList(), arrayOf("bat").toList(), arrayOf("tan", "nat").toList(),).toList()))
+    }
+
+    @Test
+    fun groupAnagrams2() {
+        assertThat(Solution().groupAnagrams(arrayOf("")), equalTo(arrayOf(arrayOf("").toList()).toList()))
+    }
+
+    @Test
+    fun groupAnagrams3() {
+        assertThat(Solution().groupAnagrams(arrayOf("a")), equalTo(arrayOf(arrayOf("a").toList()).toList()))
+    }
+}

src/test/kotlin/g0001_0100/s0051_n_queens/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0001_0100.s0051_n_queens
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun solveNQueens() {
+        assertThat(Solution().solveNQueens(4), equalTo(arrayOf(arrayOf(".Q..", "...Q", "Q...", "..Q.").toList(), arrayOf("..Q.", "Q...", "...Q", ".Q..").toList()).toList()))
+    }
+
+    @Test
+    fun solveNQueens2() {
+        assertThat(Solution().solveNQueens(1), equalTo(arrayOf(arrayOf("Q").toList()).toList()))
+    }
+}