Added tasks 932, 933, 934, 935

Author: ThanhNIT

README.md

@@ -1673,6 +1673,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0934 |[Shortest Bridge](src/main/kotlin/g0901_1000/s0934_shortest_bridge/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix | 301 | 80.95
 
 #### Day 7 Standard Traversal
 
@@ -1731,6 +1732,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 |------|----------------|-------------|-------------|----------|---------
 | 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
+| 0935 |[Knight Dialer](src/main/kotlin/g0901_1000/s0935_knight_dialer/Solution.kt)| Medium | Dynamic_Programming | 160 | 100.00
+| 0934 |[Shortest Bridge](src/main/kotlin/g0901_1000/s0934_shortest_bridge/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix, Graph_Theory_I_Day_6_Matrix_Related_Problems | 301 | 80.95
+| 0933 |[Number of Recent Calls](src/main/kotlin/g0901_1000/s0933_number_of_recent_calls/RecentCounter.kt)| Easy | Design, Queue, Data_Stream | 476 | 82.50
+| 0932 |[Beautiful Array](src/main/kotlin/g0901_1000/s0932_beautiful_array/Solution.kt)| Medium | Array, Math, Divide_and_Conquer | 145 | 100.00
 | 0931 |[Minimum Falling Path Sum](src/main/kotlin/g0901_1000/s0931_minimum_falling_path_sum/Solution.kt)| Medium | Array, Dynamic_Programming, Matrix, Dynamic_Programming_I_Day_13 | 201 | 84.21
 | 0930 |[Binary Subarrays With Sum](src/main/kotlin/g0901_1000/s0930_binary_subarrays_with_sum/Solution.kt)| Medium | Array, Hash_Table, Prefix_Sum, Sliding_Window | 250 | 93.75
 | 0929 |[Unique Email Addresses](src/main/kotlin/g0901_1000/s0929_unique_email_addresses/Solution.kt)| Easy | Array, String, Hash_Table | 207 | 89.29

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

@@ -0,0 +1,33 @@
+package g0901_1000.s0932_beautiful_array
+
+// #Medium #Array #Math #Divide_and_Conquer #2023_04_27_Time_145_ms_(100.00%)_Space_36.4_MB_(16.67%)
+
+class Solution {
+    private var memo: MutableMap<Int, IntArray>? = null
+    fun beautifulArray(n: Int): IntArray? {
+        memo = HashMap()
+        return helper(n)
+    }
+
+    private fun helper(n: Int): IntArray? {
+        if (n == 1) {
+            memo!![1] = intArrayOf(1)
+            return intArrayOf(1)
+        }
+        if (memo!!.containsKey(n)) {
+            return memo!![n]
+        }
+        val mid = (n + 1) / 2
+        val left = helper(mid)
+        val right = helper(n - mid)
+        val rst = IntArray(n)
+        for (i in 0 until mid) {
+            rst[i] = left!![i] * 2 - 1
+        }
+        for (i in mid until n) {
+            rst[i] = right!![i - mid] * 2
+        }
+        memo!![n] = rst
+        return rst
+    }
+}

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

@@ -0,0 +1,26 @@
+932\. Beautiful Array
+
+Medium
+
+An array `nums` of length `n` is **beautiful** if:
+
+*   `nums` is a permutation of the integers in the range `[1, n]`.
+*   For every `0 <= i < j < n`, there is no index `k` with `i < k < j` where `2 * nums[k] == nums[i] + nums[j]`.
+
+Given the integer `n`, return _any **beautiful** array_ `nums` _of length_ `n`. There will be at least one valid answer for the given `n`.
+
+**Example 1:**
+
+**Input:** n = 4
+
+**Output:** [2,1,4,3]
+
+**Example 2:**
+
+**Input:** n = 5
+
+**Output:** [3,1,2,5,4]
+
+**Constraints:**
+
+*   `1 <= n <= 1000`

src/main/kotlin/g0901_1000/s0933_number_of_recent_calls/RecentCounter.kt

@@ -0,0 +1,29 @@
+package g0901_1000.s0933_number_of_recent_calls
+
+// #Easy #Design #Queue #Data_Stream #2023_04_27_Time_476_ms_(82.50%)_Space_107.1_MB_(5.00%)
+
+import java.util.LinkedList
+import java.util.Queue
+
+class RecentCounter {
+    private val q: Queue<Int>
+
+    init {
+        q = LinkedList()
+    }
+
+    fun ping(t: Int): Int {
+        q.offer(t)
+        val min = t - 3000
+        while (min > q.peek()) {
+            q.poll()
+        }
+        return q.size
+    }
+}
+
+/*
+ * Your RecentCounter object will be instantiated and called as such:
+ * var obj = RecentCounter()
+ * var param_1 = obj.ping(t)
+ */

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

@@ -0,0 +1,36 @@
+933\. Number of Recent Calls
+
+Easy
+
+You have a `RecentCounter` class which counts the number of recent requests within a certain time frame.
+
+Implement the `RecentCounter` class:
+
+*   `RecentCounter()` Initializes the counter with zero recent requests.
+*   `int ping(int t)` Adds a new request at time `t`, where `t` represents some time in milliseconds, and returns the number of requests that has happened in the past `3000` milliseconds (including the new request). Specifically, return the number of requests that have happened in the inclusive range `[t - 3000, t]`.
+
+It is **guaranteed** that every call to `ping` uses a strictly larger value of `t` than the previous call.
+
+**Example 1:**
+
+**Input** ["RecentCounter", "ping", "ping", "ping", "ping"] [[], [1], [100], [3001], [3002]]
+
+**Output:** [null, 1, 2, 3, 3]
+
+**Explanation:** 
+
+RecentCounter recentCounter = new RecentCounter(); 
+
+recentCounter.ping(1); // requests = [<ins>1</ins>], range is [-2999,1], return 1 
+
+recentCounter.ping(100); // requests = [<ins>1</ins>, <ins>100</ins>], range is [-2900,100], return 2 
+
+recentCounter.ping(3001); // requests = [<ins>1</ins>, <ins>100</ins>, <ins>3001</ins>], range is [1,3001], return 3 
+
+recentCounter.ping(3002); // requests = [1, <ins>100</ins>, <ins>3001</ins>, <ins>3002</ins>], range is [2,3002], return 3
+
+**Constraints:**
+
+*   <code>1 <= t <= 10<sup>9</sup></code>
+*   Each test case will call `ping` with **strictly increasing** values of `t`.
+*   At most <code>10<sup>4</sup></code> calls will be made to `ping`.

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

@@ -0,0 +1,69 @@
+package g0901_1000.s0934_shortest_bridge
+
+// #Medium #Array #Depth_First_Search #Breadth_First_Search #Matrix
+// #Graph_Theory_I_Day_6_Matrix_Related_Problems
+// #2023_04_27_Time_301_ms_(80.95%)_Space_77.9_MB_(9.52%)
+
+class Solution {
+    private class Pair(var x: Int, var y: Int)
+
+    private val dirs = arrayOf(intArrayOf(1, 0), intArrayOf(0, 1), intArrayOf(-1, 0), intArrayOf(0, -1))
+
+    fun shortestBridge(grid: Array<IntArray>): Int {
+        val q: ArrayDeque<Pair> = ArrayDeque()
+        var flag = false
+        val visited = Array(grid.size) {
+            BooleanArray(
+                grid[0].size
+            )
+        }
+        var i = 0
+        while (i < grid.size && !flag) {
+            var j = 0
+            while (j < grid[i].size && !flag) {
+                if (grid[i][j] == 1) {
+                    dfs(grid, i, j, visited, q)
+                    flag = true
+                }
+                j++
+            }
+            i++
+        }
+        var level = -1
+        while (!q.isEmpty()) {
+            var size: Int = q.size
+            level++
+            while (size-- > 0) {
+                val rem = q.removeFirst()
+                for (dir in dirs) {
+                    val newrow = rem.x + dir[0]
+                    val newcol = rem.y + dir[1]
+                    if (newrow >= 0 && newcol >= 0 && newrow < grid.size && newcol < grid[0].size &&
+                        !visited[newrow][newcol]
+                    ) {
+                        if (grid[newrow][newcol] == 1) {
+                            return level
+                        }
+                        q.add(Pair(newrow, newcol))
+                        visited[newrow][newcol] = true
+                    }
+                }
+            }
+        }
+        return -1
+    }
+
+    private fun dfs(grid: Array<IntArray>, row: Int, col: Int, visited: Array<BooleanArray>, q: ArrayDeque<Pair>) {
+        visited[row][col] = true
+        q.add(Pair(row, col))
+        for (dir in dirs) {
+            val newrow = row + dir[0]
+            val newcol = col + dir[1]
+            if (newrow >= 0 && newcol >= 0 && newrow < grid.size && newcol < grid[0].size &&
+                !visited[newrow][newcol] && grid[newrow][newcol] == 1
+            ) {
+                dfs(grid, newrow, newcol, visited, q)
+            }
+        }
+    }
+}

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

@@ -0,0 +1,36 @@
+934\. Shortest Bridge
+
+Medium
+
+You are given an `n x n` binary matrix `grid` where `1` represents land and `0` represents water.
+
+An **island** is a 4-directionally connected group of `1`'s not connected to any other `1`'s. There are **exactly two islands** in `grid`.
+
+You may change `0`'s to `1`'s to connect the two islands to form **one island**.
+
+Return _the smallest number of_ `0`_'s you must flip to connect the two islands_.
+
+**Example 1:**
+
+**Input:** grid = [[0,1],[1,0]]
+
+**Output:** 1
+
+**Example 2:**
+
+**Input:** grid = [[0,1,0],[0,0,0],[0,0,1]]
+
+**Output:** 2
+
+**Example 3:**
+
+**Input:** grid = [[1,1,1,1,1],[1,0,0,0,1],[1,0,1,0,1],[1,0,0,0,1],[1,1,1,1,1]]
+
+**Output:** 1
+
+**Constraints:**
+
+*   `n == grid.length == grid[i].length`
+*   `2 <= n <= 100`
+*   `grid[i][j]` is either `0` or `1`.
+*   There are exactly two islands in `grid`.

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

@@ -0,0 +1,46 @@
+package g0901_1000.s0935_knight_dialer
+
+// #Medium #Dynamic_Programming #2023_04_27_Time_160_ms_(100.00%)_Space_34.7_MB_(100.00%)
+
+class Solution {
+    fun knightDialer(n: Int): Int {
+        if (n == 1) {
+            return 10
+        }
+        val mod = 1000000007
+        while (MEMO.size < n) {
+            val cur = MEMO[MEMO.size - 1]
+            val next = IntArray(10)
+            for (i in 0..9) {
+                for (d in MAP[i]!!) {
+                    next[d] = (next[d] + cur[i]) % mod
+                }
+            }
+            MEMO.add(next)
+        }
+        var sum = 0
+        for (x in MEMO[n - 1]) {
+            sum = (sum + x) % mod
+        }
+        return sum
+    }
+
+    companion object {
+        private val MAP = arrayOfNulls<IntArray>(10)
+        private val MEMO: MutableList<IntArray> = ArrayList()
+
+        init {
+            MAP[0] = intArrayOf(4, 6)
+            MAP[1] = intArrayOf(6, 8)
+            MAP[2] = intArrayOf(7, 9)
+            MAP[3] = intArrayOf(4, 8)
+            MAP[4] = intArrayOf(3, 9, 0)
+            MAP[5] = IntArray(0)
+            MAP[6] = intArrayOf(1, 7, 0)
+            MAP[7] = intArrayOf(2, 6)
+            MAP[8] = intArrayOf(1, 3)
+            MAP[9] = intArrayOf(2, 4)
+            MEMO.add(intArrayOf(1, 1, 1, 1, 1, 0, 1, 1, 1, 1))
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+935\. Knight Dialer
+
+Medium
+
+The chess knight has a **unique movement**, it may move two squares vertically and one square horizontally, or two squares horizontally and one square vertically (with both forming the shape of an **L**). The possible movements of chess knight are shown in this diagaram:
+
+A chess knight can move as indicated in the chess diagram below:
+
+![](https://assets.leetcode.com/uploads/2020/08/18/chess.jpg)
+
+We have a chess knight and a phone pad as shown below, the knight **can only stand on a numeric cell** (i.e. blue cell).
+
+![](https://assets.leetcode.com/uploads/2020/08/18/phone.jpg)
+
+Given an integer `n`, return how many distinct phone numbers of length `n` we can dial.
+
+You are allowed to place the knight **on any numeric cell** initially and then you should perform `n - 1` jumps to dial a number of length `n`. All jumps should be **valid** knight jumps.
+
+As the answer may be very large, **return the answer modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** n = 1
+
+**Output:** 10
+
+**Explanation:** We need to dial a number of length 1, so placing the knight over any numeric cell of the 10 cells is sufficient.
+
+**Example 2:**
+
+**Input:** n = 2
+
+**Output:** 20
+
+**Explanation:** All the valid number we can dial are [04, 06, 16, 18, 27, 29, 34, 38, 40, 43, 49, 60, 61, 67, 72, 76, 81, 83, 92, 94]
+
+**Example 3:**
+
+**Input:** n = 3131
+
+**Output:** 136006598
+
+**Explanation:** Please take care of the mod.
+
+**Constraints:**
+
+*   `1 <= n <= 5000`