Added tasks 912, 913, 914, 915

Author: ThanhNIT

README.md

@@ -447,6 +447,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.11'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0912 |[Sort an Array](src/main/kotlin/g0901_1000/s0912_sort_an_array/Solution.kt)| Medium | Array, Sorting, Heap_Priority_Queue, Divide_and_Conquer, Merge_Sort, Bucket_Sort, Counting_Sort, Radix_Sort | 606 | 98.48
 
 #### Udemy 2D Arrays/Matrix
 
@@ -1728,6 +1729,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.11'
 |------|----------------|-------------|-------------|----------|---------
 | 1143 |[Longest Common Subsequence](src/main/kotlin/g1101_1200/s1143_longest_common_subsequence/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming, Algorithm_II_Day_17_Dynamic_Programming, Dynamic_Programming_I_Day_19, Udemy_Dynamic_Programming | 307 | 38.36
 | 0994 |[Rotting Oranges](src/main/kotlin/g0901_1000/s0994_rotting_oranges/Solution.kt)| Medium | Array, Breadth_First_Search, Matrix, Algorithm_I_Day_9_Breadth_First_Search_Depth_First_Search, Level_2_Day_10_Graph/BFS/DFS | 308 | 57.93
+| 0915 |[Partition Array into Disjoint Intervals](src/main/kotlin/g0901_1000/s0915_partition_array_into_disjoint_intervals/Solution.kt)| Medium | Array | 510 | 76.92
+| 0914 |[X of a Kind in a Deck of Cards](src/main/kotlin/g0901_1000/s0914_x_of_a_kind_in_a_deck_of_cards/Solution.kt)| Easy | Array, Hash_Table, Math, Counting, Number_Theory | 238 | 70.00
+| 0913 |[Cat and Mouse](src/main/kotlin/g0901_1000/s0913_cat_and_mouse/Solution.kt)| Hard | Dynamic_Programming, Math, Graph, Memoization, Topological_Sort, Game_Theory | 211 | 100.00
+| 0912 |[Sort an Array](src/main/kotlin/g0901_1000/s0912_sort_an_array/Solution.kt)| Medium | Array, Sorting, Heap_Priority_Queue, Divide_and_Conquer, Merge_Sort, Bucket_Sort, Counting_Sort, Radix_Sort, Udemy_Sorting_Algorithms | 606 | 98.48
 | 0911 |[Online Election](src/main/kotlin/g0901_1000/s0911_online_election/TopVotedCandidate.kt)| Medium | Array, Hash_Table, Binary_Search, Design, Binary_Search_II_Day_20 | 766 | 83.33
 | 0910 |[Smallest Range II](src/main/kotlin/g0901_1000/s0910_smallest_range_ii/Solution.kt)| Medium | Array, Math, Sorting, Greedy, Programming_Skills_II_Day_13 | 234 | 100.00
 | 0909 |[Snakes and Ladders](src/main/kotlin/g0901_1000/s0909_snakes_and_ladders/Solution.kt)| Medium | Array, Breadth_First_Search, Matrix | 203 | 100.00

src/main/kotlin/g0901_1000/s0912_sort_an_array/Solution.kt

@@ -0,0 +1,44 @@
+package g0901_1000.s0912_sort_an_array
+
+// #Medium #Array #Sorting #Heap_Priority_Queue #Divide_and_Conquer #Merge_Sort #Bucket_Sort
+// #Counting_Sort #Radix_Sort #Udemy_Sorting_Algorithms
+// #2023_04_16_Time_606_ms_(98.48%)_Space_47.6_MB_(57.11%)
+
+class Solution {
+    fun sortArray(nums: IntArray): IntArray {
+        return mergeSort(nums, 0, nums.size - 1)
+    }
+
+    private fun mergeSort(arr: IntArray, lo: Int, hi: Int): IntArray {
+        if (lo == hi) {
+            val sortedArr = IntArray(1)
+            sortedArr[0] = arr[lo]
+            return sortedArr
+        }
+        val mid = (lo + hi) / 2
+        val leftArray = mergeSort(arr, lo, mid)
+        val rightArray = mergeSort(arr, mid + 1, hi)
+        return mergeSortedArray(leftArray, rightArray)
+    }
+
+    private fun mergeSortedArray(a: IntArray, b: IntArray): IntArray {
+        val ans = IntArray(a.size + b.size)
+        var i = 0
+        var j = 0
+        var k = 0
+        while (i < a.size && j < b.size) {
+            if (a[i] < b[j]) {
+                ans[k++] = a[i++]
+            } else {
+                ans[k++] = b[j++]
+            }
+        }
+        while (i < a.size) {
+            ans[k++] = a[i++]
+        }
+        while (j < b.size) {
+            ans[k++] = b[j++]
+        }
+        return ans
+    }
+}

src/main/kotlin/g0901_1000/s0912_sort_an_array/readme.md

@@ -0,0 +1,28 @@
+912\. Sort an Array
+
+Medium
+
+Given an array of integers `nums`, sort the array in ascending order and return it.
+
+You must solve the problem **without using any built-in** functions in `O(nlog(n))` time complexity and with the smallest space complexity possible.
+
+**Example 1:**
+
+**Input:** nums = [5,2,3,1]
+
+**Output:** [1,2,3,5]
+
+**Explanation:** After sorting the array, the positions of some numbers are not changed (for example, 2 and 3), while the positions of other numbers are changed (for example, 1 and 5).
+
+**Example 2:**
+
+**Input:** nums = [5,1,1,2,0,0]
+
+**Output:** [0,0,1,1,2,5]
+
+**Explanation:** Note that the values of nums are not necessairly unique.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 5 * 10<sup>4</sup></code>
+*   <code>-5 * 10<sup>4</sup> <= nums[i] <= 5 * 10<sup>4</sup></code>

src/main/kotlin/g0901_1000/s0913_cat_and_mouse/Solution.kt

@@ -0,0 +1,83 @@
+package g0901_1000.s0913_cat_and_mouse
+
+// #Hard #Dynamic_Programming #Math #Graph #Memoization #Topological_Sort #Game_Theory
+// #2023_04_16_Time_211_ms_(100.00%)_Space_37.1_MB_(100.00%)
+
+import java.util.LinkedList
+import java.util.Queue
+
+class Solution {
+    fun catMouseGame(graph: Array<IntArray>): Int {
+        val n = graph.size
+        val states = Array(n) {
+            Array(n) {
+                IntArray(
+                    2
+                )
+            }
+        }
+        val degree = Array(n) {
+            Array(n) {
+                IntArray(
+                    2
+                )
+            }
+        }
+        for (m in 0 until n) {
+            for (c in 0 until n) {
+                degree[m][c][MOUSE] = graph[m].size
+                degree[m][c][CAT] = graph[c].size
+                for (node in graph[c]) {
+                    if (node == 0) {
+                        --degree[m][c][CAT]
+                        break
+                    }
+                }
+            }
+        }
+        val q: Queue<IntArray> = LinkedList()
+        for (i in 1 until n) {
+            states[0][i][MOUSE] = MOUSE_WIN
+            states[0][i][CAT] = MOUSE_WIN
+            states[i][i][MOUSE] = CAT_WIN
+            states[i][i][CAT] = CAT_WIN
+            q.offer(intArrayOf(0, i, MOUSE, MOUSE_WIN))
+            q.offer(intArrayOf(i, i, MOUSE, CAT_WIN))
+            q.offer(intArrayOf(0, i, CAT, MOUSE_WIN))
+            q.offer(intArrayOf(i, i, CAT, CAT_WIN))
+        }
+        while (!q.isEmpty()) {
+            val state = q.poll()
+            val mouse = state[0]
+            val cat = state[1]
+            val turn = state[2]
+            val result = state[3]
+            if (mouse == 1 && cat == 2 && turn == MOUSE) {
+                return result
+            }
+            val prevTurn = 1 - turn
+            for (prev in graph[if (prevTurn == MOUSE) mouse else cat]) {
+                val prevMouse = if (prevTurn == MOUSE) prev else mouse
+                val prevCat = if (prevTurn == CAT) prev else cat
+                if (prevCat != 0 && states[prevMouse][prevCat][prevTurn] == DRAW &&
+                    (
+                        prevTurn == MOUSE && result == MOUSE_WIN || prevTurn == CAT && result == CAT_WIN ||
+                            --degree[prevMouse][prevCat][prevTurn] == 0
+                        )
+                ) {
+                    states[prevMouse][prevCat][prevTurn] = result
+                    q.offer(intArrayOf(prevMouse, prevCat, prevTurn, result))
+                }
+            }
+        }
+        return DRAW
+    }
+
+    companion object {
+        private const val DRAW = 0
+        private const val MOUSE_WIN = 1
+        private const val CAT_WIN = 2
+        private const val MOUSE = 0
+        private const val CAT = 1
+    }
+}

src/main/kotlin/g0901_1000/s0913_cat_and_mouse/readme.md

@@ -0,0 +1,50 @@
+913\. Cat and Mouse
+
+Hard
+
+A game on an **undirected** graph is played by two players, Mouse and Cat, who alternate turns.
+
+The graph is given as follows: `graph[a]` is a list of all nodes `b` such that `ab` is an edge of the graph.
+
+The mouse starts at node `1` and goes first, the cat starts at node `2` and goes second, and there is a hole at node `0`.
+
+During each player's turn, they **must** travel along one edge of the graph that meets where they are. For example, if the Mouse is at node 1, it **must** travel to any node in `graph[1]`.
+
+Additionally, it is not allowed for the Cat to travel to the Hole (node 0.)
+
+Then, the game can end in three ways:
+
+*   If ever the Cat occupies the same node as the Mouse, the Cat wins.
+*   If ever the Mouse reaches the Hole, the Mouse wins.
+*   If ever a position is repeated (i.e., the players are in the same position as a previous turn, and it is the same player's turn to move), the game is a draw.
+
+Given a `graph`, and assuming both players play optimally, return
+
+*   `1` if the mouse wins the game,
+*   `2` if the cat wins the game, or
+*   `0` if the game is a draw.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/17/cat1.jpg)
+
+**Input:** graph = [[2,5],[3],[0,4,5],[1,4,5],[2,3],[0,2,3]]
+
+**Output:** 0
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/17/cat2.jpg)
+
+**Input:** graph = [[1,3],[0],[3],[0,2]]
+
+**Output:** 1
+
+**Constraints:**
+
+*   `3 <= graph.length <= 50`
+*   `1 <= graph[i].length < graph.length`
+*   `0 <= graph[i][j] < graph.length`
+*   `graph[i][j] != i`
+*   `graph[i]` is unique.
+*   The mouse and the cat can always move.

src/main/kotlin/g0901_1000/s0914_x_of_a_kind_in_a_deck_of_cards/Solution.kt

@@ -0,0 +1,29 @@
+package g0901_1000.s0914_x_of_a_kind_in_a_deck_of_cards
+
+// #Easy #Array #Hash_Table #Math #Counting #Number_Theory
+// #2023_04_16_Time_238_ms_(70.00%)_Space_37.6_MB_(60.00%)
+
+class Solution {
+    fun hasGroupsSizeX(deck: IntArray): Boolean {
+        val map: HashMap<Int, Int> = HashMap()
+        for (j in deck) {
+            if (map.containsKey(j)) {
+                map[j] = map[j]!! + 1
+            } else {
+                map[j] = 1
+            }
+        }
+        var x = map[deck[0]]!!
+
+        for (entry in map.entries.iterator()) {
+            x = gcd(x, entry.value)
+        }
+        return x >= 2
+    }
+
+    private fun gcd(a: Int, b: Int): Int {
+        return if (b == 0) {
+            a
+        } else gcd(b, a % b)
+    }
+}

src/main/kotlin/g0901_1000/s0914_x_of_a_kind_in_a_deck_of_cards/readme.md

@@ -0,0 +1,33 @@
+914\. X of a Kind in a Deck of Cards
+
+Easy
+
+You are given an integer array `deck` where `deck[i]` represents the number written on the <code>i<sup>th</sup></code> card.
+
+Partition the cards into **one or more groups** such that:
+
+*   Each group has **exactly** `x` cards where `x > 1`, and
+*   All the cards in one group have the same integer written on them.
+
+Return `true` _if such partition is possible, or_ `false` _otherwise_.
+
+**Example 1:**
+
+**Input:** deck = [1,2,3,4,4,3,2,1]
+
+**Output:** true
+
+**Explanation:**: Possible partition [1,1],[2,2],[3,3],[4,4].
+
+**Example 2:**
+
+**Input:** deck = [1,1,1,2,2,2,3,3]
+
+**Output:** false
+
+**Explanation:**: No possible partition.
+
+**Constraints:**
+
+*   <code>1 <= deck.length <= 10<sup>4</sup></code>
+*   <code>0 <= deck[i] < 10<sup>4</sup></code>

src/main/kotlin/g0901_1000/s0915_partition_array_into_disjoint_intervals/Solution.kt

@@ -0,0 +1,20 @@
+package g0901_1000.s0915_partition_array_into_disjoint_intervals
+
+// #Medium #Array #2023_04_16_Time_510_ms_(76.92%)_Space_53.2_MB_(69.23%)
+
+class Solution {
+    fun partitionDisjoint(nums: IntArray): Int {
+        var res = 0
+        var leftMax = nums[0]
+        var greater = nums[0]
+        for (i in 1 until nums.size) {
+            if (greater <= nums[i]) {
+                greater = nums[i]
+            } else if (nums[i] < leftMax) {
+                res = i
+                leftMax = greater
+            }
+        }
+        return res + 1
+    }
+}

src/main/kotlin/g0901_1000/s0915_partition_array_into_disjoint_intervals/readme.md

@@ -0,0 +1,35 @@
+915\. Partition Array into Disjoint Intervals
+
+Medium
+
+Given an integer array `nums`, partition it into two (contiguous) subarrays `left` and `right` so that:
+
+*   Every element in `left` is less than or equal to every element in `right`.
+*   `left` and `right` are non-empty.
+*   `left` has the smallest possible size.
+
+Return _the length of_ `left` _after such a partitioning_.
+
+Test cases are generated such that partitioning exists.
+
+**Example 1:**
+
+**Input:** nums = [5,0,3,8,6]
+
+**Output:** 3
+
+**Explanation:** left = [5,0,3], right = [8,6]
+
+**Example 2:**
+
+**Input:** nums = [1,1,1,0,6,12]
+
+**Output:** 4
+
+**Explanation:** left = [1,1,1,0], right = [6,12]
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>6</sup></code>
+*   There is at least one valid answer for the given input.

src/test/kotlin/g0901_1000/s0912_sort_an_array/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0901_1000.s0912_sort_an_array
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun sortArray() {
+        assertThat(
+            Solution().sortArray(intArrayOf(5, 2, 3, 1)), equalTo(intArrayOf(1, 2, 3, 5))
+        )
+    }
+
+    @Test
+    fun sortArray2() {
+        assertThat(
+            Solution().sortArray(intArrayOf(5, 1, 1, 2, 0, 0)),
+            equalTo(intArrayOf(0, 0, 1, 1, 2, 5))
+        )
+    }
+}