Added tasks 908, 909, 910, 911

Author: ThanhNIT

README.md

@@ -1273,6 +1273,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.11'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0911 |[Online Election](src/main/kotlin/g0901_1000/s0911_online_election/TopVotedCandidate.kt)| Medium | Array, Hash_Table, Binary_Search, Design | 766 | 83.33
 
 ### Dynamic Programming I
 
@@ -1583,6 +1584,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.11'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0304 |[Range Sum Query 2D - Immutable](src.save/main/kotlin/g0301_0400/s0304_range_sum_query_2d_immutable/NumMatrix.kt)| Medium | Array, Matrix, Design, Prefix_Sum | 1373 | 85.71
+| 0910 |[Smallest Range II](src/main/kotlin/g0901_1000/s0910_smallest_range_ii/Solution.kt)| Medium | Array, Math, Sorting, Greedy | 234 | 100.00
 
 #### Day 14
 
@@ -1726,6 +1728,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
+| 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
+| 0908 |[Smallest Range I](src/main/kotlin/g0901_1000/s0908_smallest_range_i/Solution.kt)| Easy | Array, Math | 202 | 87.50
 | 0907 |[Sum of Subarray Minimums](src/main/kotlin/g0901_1000/s0907_sum_of_subarray_minimums/Solution.kt)| Medium | Array, Dynamic_Programming, Stack, Monotonic_Stack | 341 | 100.00
 | 0906 |[Super Palindromes](src/main/kotlin/g0901_1000/s0906_super_palindromes/Solution.kt)| Hard | Math, Enumeration | 153 | 100.00
 | 0905 |[Sort Array By Parity](src/main/kotlin/g0901_1000/s0905_sort_array_by_parity/Solution.kt)| Easy | Array, Sorting, Two_Pointers | 219 | 75.00

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

@@ -0,0 +1,17 @@
+package g0901_1000.s0908_smallest_range_i
+
+// #Easy #Array #Math #2023_04_15_Time_202_ms_(87.50%)_Space_37.2_MB_(75.00%)
+
+class Solution {
+    fun smallestRangeI(nums: IntArray, k: Int): Int {
+        var min = Int.MAX_VALUE
+        var max = Int.MIN_VALUE
+        for (num in nums) {
+            min = min.coerceAtMost(num)
+            max = max.coerceAtLeast(num)
+        }
+        return if (min + k >= max - k) {
+            0
+        } else max - k - (min + k)
+    }
+}

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

@@ -0,0 +1,41 @@
+908\. Smallest Range I
+
+Easy
+
+You are given an integer array `nums` and an integer `k`.
+
+In one operation, you can choose any index `i` where `0 <= i < nums.length` and change `nums[i]` to `nums[i] + x` where `x` is an integer from the range `[-k, k]`. You can apply this operation **at most once** for each index `i`.
+
+The **score** of `nums` is the difference between the maximum and minimum elements in `nums`.
+
+Return _the minimum **score** of_ `nums` _after applying the mentioned operation at most once for each index in it_.
+
+**Example 1:**
+
+**Input:** nums = [1], k = 0
+
+**Output:** 0
+
+**Explanation:** The score is max(nums) - min(nums) = 1 - 1 = 0.
+
+**Example 2:**
+
+**Input:** nums = [0,10], k = 2
+
+**Output:** 6
+
+**Explanation:** Change nums to be [2, 8]. The score is max(nums) - min(nums) = 8 - 2 = 6.
+
+**Example 3:**
+
+**Input:** nums = [1,3,6], k = 3
+
+**Output:** 0
+
+**Explanation:** Change nums to be [4, 4, 4]. The score is max(nums) - min(nums) = 4 - 4 = 0.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>4</sup></code>
+*   <code>0 <= k <= 10<sup>4</sup></code>

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

@@ -0,0 +1,53 @@
+package g0901_1000.s0909_snakes_and_ladders
+
+// #Medium #Array #Breadth_First_Search #Matrix
+// #2023_04_15_Time_203_ms_(100.00%)_Space_36_MB_(100.00%)
+
+import java.util.LinkedList
+import java.util.Queue
+
+class Solution {
+    private var size = 0
+    fun snakesAndLadders(board: Array<IntArray>): Int {
+        val queue: Queue<Int> = LinkedList()
+        size = board.size
+        val target = size * size
+        val visited = BooleanArray(target)
+        queue.add(1)
+        visited[0] = true
+        var step = 0
+        while (!queue.isEmpty()) {
+            val queueSize = queue.size
+            for (i in 0 until queueSize) {
+                val previousLabel = queue.poll()
+                if (previousLabel == target) {
+                    return step
+                }
+                for (currentLabel in previousLabel + 1..Math.min(target, previousLabel + 6)) {
+                    if (visited[currentLabel - 1]) {
+                        continue
+                    }
+                    visited[currentLabel - 1] = true
+                    val position = indexToPosition(currentLabel)
+                    if (board[position[0]][position[1]] == -1) {
+                        queue.add(currentLabel)
+                    } else {
+                        queue.add(board[position[0]][position[1]])
+                    }
+                }
+            }
+            step++
+        }
+        return -1
+    }
+
+    private fun indexToPosition(index: Int): IntArray {
+        val vertical = size - 1 - (index - 1) / size
+        val horizontal: Int = if ((size - vertical) % 2 == 1) {
+            (index - 1) % size
+        } else {
+            size - 1 - (index - 1) % size
+        }
+        return intArrayOf(vertical, horizontal)
+    }
+}

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

@@ -0,0 +1,55 @@
+909\. Snakes and Ladders
+
+Medium
+
+You are given an `n x n` integer matrix `board` where the cells are labeled from `1` to <code>n<sup>2</sup></code> in a [**Boustrophedon style**](https://en.wikipedia.org/wiki/Boustrophedon) starting from the bottom left of the board (i.e. `board[n - 1][0]`) and alternating direction each row.
+
+You start on square `1` of the board. In each move, starting from square `curr`, do the following:
+
+*   Choose a destination square `next` with a label in the range <code>[curr + 1, min(curr + 6, n<sup>2</sup>)]</code>.
+    *   This choice simulates the result of a standard **6-sided die roll**: i.e., there are always at most 6 destinations, regardless of the size of the board.
+*   If `next` has a snake or ladder, you **must** move to the destination of that snake or ladder. Otherwise, you move to `next`.
+*   The game ends when you reach the square <code>n<sup>2</sup></code>.
+
+A board square on row `r` and column `c` has a snake or ladder if `board[r][c] != -1`. The destination of that snake or ladder is `board[r][c]`. Squares `1` and <code>n<sup>2</sup></code> do not have a snake or ladder.
+
+Note that you only take a snake or ladder at most once per move. If the destination to a snake or ladder is the start of another snake or ladder, you do **not** follow the subsequent snake or ladder.
+
+*   For example, suppose the board is `[[-1,4],[-1,3]]`, and on the first move, your destination square is `2`. You follow the ladder to square `3`, but do **not** follow the subsequent ladder to `4`.
+
+Return _the least number of moves required to reach the square_ <code>n<sup>2</sup></code>_. If it is not possible to reach the square, return_ `-1`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/09/23/snakes.png)
+
+**Input:** board = [[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,35,-1,-1,13,-1],[-1,-1,-1,-1,-1,-1],[-1,15,-1,-1,-1,-1]]
+
+**Output:** 4
+
+**Explanation:**
+
+In the beginning, you start at square 1 (at row 5, column 0).
+
+You decide to move to square 2 and must take the ladder to square 15.
+
+You then decide to move to square 17 and must take the snake to square 13.
+
+You then decide to move to square 14 and must take the ladder to square 35.
+
+You then decide to move to square 36, ending the game.
+
+This is the lowest possible number of moves to reach the last square, so return 4.
+
+**Example 2:**
+
+**Input:** board = [[-1,-1],[-1,3]]
+
+**Output:** 1
+
+**Constraints:**
+
+*   `n == board.length == board[i].length`
+*   `2 <= n <= 20`
+*   `grid[i][j]` is either `-1` or in the range <code>[1, n<sup>2</sup>]</code>.
+*   The squares labeled `1` and <code>n<sup>2</sup></code> do not have any ladders or snakes.

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

@@ -0,0 +1,22 @@
+package g0901_1000.s0910_smallest_range_ii
+
+// #Medium #Array #Math #Sorting #Greedy #Programming_Skills_II_Day_13
+// #2023_04_15_Time_234_ms_(100.00%)_Space_37.1_MB_(100.00%)
+
+import java.util.Arrays
+
+class Solution {
+    fun smallestRangeII(nums: IntArray, k: Int): Int {
+        Arrays.sort(nums)
+        val n = nums.size
+        var ans = nums[n - 1] - nums[0]
+        val min = nums[0] + k
+        val max = nums[n - 1] - k
+        for (i in 0 until n - 1) {
+            val mx = max.coerceAtLeast(nums[i] + k)
+            val mi = min.coerceAtMost(nums[i + 1] - k)
+            ans = ans.coerceAtMost(mx - mi)
+        }
+        return ans
+    }
+}

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

@@ -0,0 +1,41 @@
+910\. Smallest Range II
+
+Medium
+
+You are given an integer array `nums` and an integer `k`.
+
+For each index `i` where `0 <= i < nums.length`, change `nums[i]` to be either `nums[i] + k` or `nums[i] - k`.
+
+The **score** of `nums` is the difference between the maximum and minimum elements in `nums`.
+
+Return _the minimum **score** of_ `nums` _after changing the values at each index_.
+
+**Example 1:**
+
+**Input:** nums = [1], k = 0
+
+**Output:** 0
+
+**Explanation:** The score is max(nums) - min(nums) = 1 - 1 = 0.
+
+**Example 2:**
+
+**Input:** nums = [0,10], k = 2
+
+**Output:** 6
+
+**Explanation:** Change nums to be [2, 8]. The score is max(nums) - min(nums) = 8 - 2 = 6.
+
+**Example 3:**
+
+**Input:** nums = [1,3,6], k = 3
+
+**Output:** 3
+
+**Explanation:** Change nums to be [4, 6, 3]. The score is max(nums) - min(nums) = 6 - 3 = 3.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>4</sup></code>
+*   <code>0 <= k <= 10<sup>4</sup></code>

src/main/kotlin/g0901_1000/s0911_online_election/TopVotedCandidate.kt

@@ -0,0 +1,51 @@
+package g0901_1000.s0911_online_election
+
+// #Medium #Array #Hash_Table #Binary_Search #Design #Binary_Search_II_Day_20
+// #2023_04_15_Time_766_ms_(83.33%)_Space_66.7_MB_(100.00%)
+
+class TopVotedCandidate(persons: IntArray, private val times: IntArray) {
+    private val winnersAtTimeT: IntArray = IntArray(times.size)
+
+    init {
+        val counterArray = IntArray(persons.size)
+        var maxVote = 0
+        var maxVotedPerson = 0
+        for (i in persons.indices) {
+            val person = persons[i]
+            val voteCount = counterArray[person]
+            if (voteCount + 1 >= maxVote) {
+                maxVote = voteCount + 1
+                maxVotedPerson = person
+            }
+            winnersAtTimeT[i] = maxVotedPerson
+            counterArray[persons[i]] = voteCount + 1
+        }
+    }
+
+    fun q(t: Int): Int {
+        var lo = 0
+        var hi = times.size - 1
+        if (t >= times[hi]) {
+            lo = hi
+        } else {
+            while (lo < hi - 1) {
+                val mid = lo + (hi - lo) / 2
+                if (times[mid] == t) {
+                    lo = mid
+                    break
+                } else if (times[mid] > t) {
+                    hi = mid
+                } else {
+                    lo = mid
+                }
+            }
+        }
+        return winnersAtTimeT[lo]
+    }
+}
+
+/**
+ * Your TopVotedCandidate object will be instantiated and called as such:
+ * var obj = TopVotedCandidate(persons, times)
+ * var param_1 = obj.q(t)
+ */

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

@@ -0,0 +1,38 @@
+911\. Online Election
+
+Medium
+
+You are given two integer arrays `persons` and `times`. In an election, the <code>i<sup>th</sup></code> vote was cast for `persons[i]` at time `times[i]`.
+
+For each query at a time `t`, find the person that was leading the election at time `t`. Votes cast at time `t` will count towards our query. In the case of a tie, the most recent vote (among tied candidates) wins.
+
+Implement the `TopVotedCandidate` class:
+
+*   `TopVotedCandidate(int[] persons, int[] times)` Initializes the object with the `persons` and `times` arrays.
+*   `int q(int t)` Returns the number of the person that was leading the election at time `t` according to the mentioned rules.
+
+**Example 1:**
+
+**Input** ["TopVotedCandidate", "q", "q", "q", "q", "q", "q"] [[[0, 1, 1, 0, 0, 1, 0], [0, 5, 10, 15, 20, 25, 30]], [3], [12], [25], [15], [24], [8]]
+
+**Output:** [null, 0, 1, 1, 0, 0, 1]
+
+**Explanation:** 
+    
+    TopVotedCandidate topVotedCandidate = new TopVotedCandidate([0, 1, 1, 0, 0, 1, 0], [0, 5, 10, 15, 20, 25, 30]); 
+    topVotedCandidate.q(3); // return 0, At time 3, the votes are [0], and 0 is leading. 
+    topVotedCandidate.q(12); // return 1, At time 12, the votes are [0,1,1], and 1 is leading. 
+    topVotedCandidate.q(25); // return 1, At time 25, the votes are [0,1,1,0,0,1], and 1 is leading (as ties go to the most recent vote.) 
+    topVotedCandidate.q(15); // return 0 
+    topVotedCandidate.q(24); // return 0 
+    topVotedCandidate.q(8); // return 1
+
+**Constraints:**
+
+*   `1 <= persons.length <= 5000`
+*   `times.length == persons.length`
+*   `0 <= persons[i] < persons.length`
+*   <code>0 <= times[i] <= 10<sup>9</sup></code>
+*   `times` is sorted in a strictly increasing order.
+*   <code>times[0] <= t <= 10<sup>9</sup></code>
+*   At most <code>10<sup>4</sup></code> calls will be made to `q`.

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

@@ -0,0 +1,22 @@
+package g0901_1000.s0908_smallest_range_i
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun smallestRangeI() {
+        assertThat(Solution().smallestRangeI(intArrayOf(1), 0), equalTo(0))
+    }
+
+    @Test
+    fun smallestRangeI2() {
+        assertThat(Solution().smallestRangeI(intArrayOf(0, 10), 2), equalTo(6))
+    }
+
+    @Test
+    fun smallestRangeI3() {
+        assertThat(Solution().smallestRangeI(intArrayOf(1, 3, 6), 3), equalTo(0))
+    }
+}