Added tasks 396, 398, 399, 400.

Author: ThanhNIT

README.md

@@ -1618,7 +1618,11 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | 0438 |[Find All Anagrams in a String](src/main/kotlin/g0401_0500/s0438_find_all_anagrams_in_a_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Sliding_Window, Algorithm_II_Day_5_Sliding_Window, Programming_Skills_II_Day_12, Level_1_Day_12_Sliding_Window/Two_Pointer | 561 | 54.68
 | 0437 |[Path Sum III](src/main/kotlin/g0401_0500/s0437_path_sum_iii/Solution.kt)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Level_2_Day_7_Tree | 403 | 54.12
 | 0416 |[Partition Equal Subset Sum](src/main/kotlin/g0401_0500/s0416_partition_equal_subset_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Level_2_Day_13_Dynamic_Programming | 509 | 57.56
+| 0400 |[Nth Digit](src/main/kotlin/g0301_0400/s0400_nth_digit/Solution.kt)| Medium | Math, Binary_Search | 271 | 50.00
+| 0399 |[Evaluate Division](src/main/kotlin/g0301_0400/s0399_evaluate_division/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Graph, Union_Find, Shortest_Path | 183 | 91.49
+| 0398 |[Random Pick Index](src/main/kotlin/g0301_0400/s0398_random_pick_index/Solution.kt)| Medium | Hash_Table, Math, Randomized, Reservoir_Sampling | 1091 | 75.00
 | 0397 |[Integer Replacement](src/main/kotlin/g0301_0400/s0397_integer_replacement/Solution.kt)| Medium | Dynamic_Programming, Greedy, Bit_Manipulation, Memoization | 145 | 87.50
+| 0396 |[Rotate Function](src/main/kotlin/g0301_0400/s0396_rotate_function/Solution.kt)| Medium | Array, Dynamic_Programming, Math | 562 | 87.50
 | 0395 |[Longest Substring with At Least K Repeating Characters](src/main/kotlin/g0301_0400/s0395_longest_substring_with_at_least_k_repeating_characters/Solution.kt)| Medium | Top_Interview_Questions, String, Hash_Table, Sliding_Window, Divide_and_Conquer | 274 | 66.67
 | 0394 |[Decode String](src/main/kotlin/g0301_0400/s0394_decode_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Stack, Recursion, Level_1_Day_14_Stack, Udemy_Strings | 224 | 64.86
 | 0393 |[UTF-8 Validation](src/main/kotlin/g0301_0400/s0393_utf_8_validation/Solution.kt)| Medium | Array, Bit_Manipulation | 219 | 100.00

src/main/kotlin/g0301_0400/s0396_rotate_function/Solution.kt

@@ -0,0 +1,21 @@
+package g0301_0400.s0396_rotate_function
+
+// #Medium #Array #Dynamic_Programming #Math #2022_11_30_Time_571_ms_(87.50%)_Space_54.1_MB_(62.50%)
+
+class Solution {
+    fun maxRotateFunction(nums: IntArray): Int {
+        var allSum = 0
+        val len = nums.size
+        var f = 0
+        for (i in 0 until len) {
+            f += i * nums[i]
+            allSum += nums[i]
+        }
+        var max = f
+        for (i in len - 1 downTo 1) {
+            f += allSum - len * nums[i]
+            max = Math.max(f, max)
+        }
+        return max
+    }
+}

src/main/kotlin/g0301_0400/s0396_rotate_function/readme.md

@@ -0,0 +1,43 @@
+396\. Rotate Function
+
+Medium
+
+You are given an integer array `nums` of length `n`.
+
+Assume <code>arr<sub>k</sub></code> to be an array obtained by rotating `nums` by `k` positions clock-wise. We define the **rotation function** `F` on `nums` as follow:
+
+*   <code>F(k) = 0 * arr<sub>k</sub>[0] + 1 * arr<sub>k</sub>[1] + ... + (n - 1) * arr<sub>k</sub>[n - 1].</code>
+
+Return _the maximum value of_ `F(0), F(1), ..., F(n-1)`.
+
+The test cases are generated so that the answer fits in a **32-bit** integer.
+
+**Example 1:**
+
+**Input:** nums = [4,3,2,6]
+
+**Output:** 26
+
+**Explanation:**
+
+F(0) = (0 * 4) + (1 * 3) + (2 * 2) + (3 * 6) = 0 + 3 + 4 + 18 = 25
+
+F(1) = (0 * 6) + (1 * 4) + (2 * 3) + (3 * 2) = 0 + 4 + 6 + 6 = 16
+
+F(2) = (0 * 2) + (1 * 6) + (2 * 4) + (3 * 3) = 0 + 6 + 8 + 9 = 23
+
+F(3) = (0 * 3) + (1 * 2) + (2 * 6) + (3 * 4) = 0 + 2 + 12 + 12 = 26
+
+So the maximum value of F(0), F(1), F(2), F(3) is F(3) = 26.
+
+**Example 2:**
+
+**Input:** nums = [100]
+
+**Output:** 0
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `-100 <= nums[i] <= 100`

src/main/kotlin/g0301_0400/s0398_random_pick_index/Solution.kt

@@ -0,0 +1,34 @@
+package g0301_0400.s0398_random_pick_index
+
+// #Medium #Hash_Table #Math #Randomized #Reservoir_Sampling
+// #2022_11_29_Time_1091_ms_(75.00%)_Space_84.3_MB_(25.00%)
+
+import java.util.Random
+
+@Suppress("kotlin:S2245")
+class Solution(nums: IntArray) {
+    // O(n) time | O(n) space
+    private val map: MutableMap<Int, MutableList<Int>>
+    private val rand: Random
+
+    init {
+        map = HashMap()
+        rand = Random()
+        for (i in nums.indices) {
+            map.computeIfAbsent(
+                nums[i]
+            ) { ArrayList() }.add(i)
+        }
+    }
+
+    fun pick(target: Int): Int {
+        val list: List<Int> = map[target]!!
+        return list[rand.nextInt(list.size)]
+    }
+}
+
+/*
+ * Your Solution object will be instantiated and called as such:
+ * var obj = Solution(nums)
+ * var param_1 = obj.pick(target)
+ */

src/main/kotlin/g0301_0400/s0398_random_pick_index/readme.md

@@ -0,0 +1,33 @@
+398\. Random Pick Index
+
+Medium
+
+Given an integer array `nums` with possible **duplicates**, randomly output the index of a given `target` number. You can assume that the given target number must exist in the array.
+
+Implement the `Solution` class:
+
+*   `Solution(int[] nums)` Initializes the object with the array `nums`.
+*   `int pick(int target)` Picks a random index `i` from `nums` where `nums[i] == target`. If there are multiple valid i's, then each index should have an equal probability of returning.
+
+**Example 1:**
+
+**Input**
+
+    ["Solution", "pick", "pick", "pick"] 
+    [[[1, 2, 3, 3, 3]], [3], [1], [3]]
+
+**Output:** [null, 4, 0, 2]
+
+**Explanation:**
+
+    Solution solution = new Solution([1, 2, 3, 3, 3]); 
+    solution.pick(3); // It should return either index 2, 3, or 4 randomly. Each index should have equal probability of returning. 
+    solution.pick(1); // It should return 0. Since in the array only nums[0] is equal to 1. 
+    solution.pick(3); // It should return either index 2, 3, or 4 randomly. Each index should have equal probability of returning.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 2 * 10<sup>4</sup></code>
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
+*   `target` is an integer from `nums`.
+*   At most <code>10<sup>4</sup></code> calls will be made to `pick`.

src/main/kotlin/g0301_0400/s0399_evaluate_division/Solution.kt

@@ -0,0 +1,65 @@
+package g0301_0400.s0399_evaluate_division
+
+// #Medium #Array #Depth_First_Search #Breadth_First_Search #Graph #Union_Find #Shortest_Path
+// #2022_11_29_Time_183_ms_(91.49%)_Space_34.6_MB_(95.74%)
+
+class Solution {
+    private var root: MutableMap<String?, String?>? = null
+    private var rate: MutableMap<String?, Double>? = null
+    fun calcEquation(
+        equations: List<List<String?>>,
+        values: DoubleArray,
+        queries: List<List<String?>>
+    ): DoubleArray {
+        root = HashMap()
+        rate = HashMap()
+        val n = equations.size
+        for (equation in equations) {
+            val x = equation[0]
+            val y = equation[1]
+            (root as HashMap<String?, String?>)[x] = x
+            (root as HashMap<String?, String?>)[y] = y
+            (rate as HashMap<String?, Double>)[x] = 1.0
+            (rate as HashMap<String?, Double>)[y] = 1.0
+        }
+        for (i in 0 until n) {
+            val x = equations[i][0]
+            val y = equations[i][1]
+            union(x, y, values[i])
+        }
+        val result = DoubleArray(queries.size)
+        for (i in queries.indices) {
+            val x = queries[i][0]
+            val y = queries[i][1]
+            if (!(root as HashMap<String?, String?>).containsKey(x) ||
+                !(root as HashMap<String?, String?>).containsKey(y)
+            ) {
+                result[i] = -1.0
+                continue
+            }
+            val rootX = findRoot(x, x, 1.0)
+            val rootY = findRoot(y, y, 1.0)
+            result[i] = if (rootX == rootY) (rate as HashMap<String?, Double>).get(x)!! /
+                (rate as HashMap<String?, Double>).get(y)!! else -1.0
+        }
+        return result
+    }
+
+    private fun union(x: String?, y: String?, v: Double) {
+        val rootX = findRoot(x, x, 1.0)
+        val rootY = findRoot(y, y, 1.0)
+        root!![rootX] = rootY
+        val r1 = rate!![x]!!
+        val r2 = rate!![y]!!
+        rate!![rootX] = v * r2 / r1
+    }
+
+    private fun findRoot(originalX: String?, x: String?, r: Double): String? {
+        if (root!![x] == x) {
+            root!![originalX] = x
+            rate!![originalX] = r * rate!![x]!!
+            return x
+        }
+        return findRoot(originalX, root!![x], r * rate!![x]!!)
+    }
+}

src/main/kotlin/g0301_0400/s0399_evaluate_division/readme.md

@@ -0,0 +1,43 @@
+399\. Evaluate Division
+
+Medium
+
+You are given an array of variable pairs `equations` and an array of real numbers `values`, where <code>equations[i] = [A<sub>i</sub>, B<sub>i</sub>]</code> and `values[i]` represent the equation <code>A<sub>i</sub> / B<sub>i</sub> = values[i]</code>. Each <code>A<sub>i</sub></code> or <code>B<sub>i</sub></code> is a string that represents a single variable.
+
+You are also given some `queries`, where <code>queries[j] = [C<sub>j</sub>, D<sub>j</sub>]</code> represents the <code>j<sup>th</sup></code> query where you must find the answer for <code>C<sub>j</sub> / D<sub>j</sub> = ?</code>.
+
+Return _the answers to all queries_. If a single answer cannot be determined, return `-1.0`.
+
+**Note:** The input is always valid. You may assume that evaluating the queries will not result in division by zero and that there is no contradiction.
+
+**Example 1:**
+
+**Input:** equations = [["a","b"],["b","c"]], values = [2.0,3.0], queries = [["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]]
+
+**Output:** [6.00000,0.50000,-1.00000,1.00000,-1.00000]
+
+**Explanation:** Given: _a / b = 2.0_, _b / c = 3.0_ queries are: _a / c = ?_, _b / a = ?_, _a / e = ?_, _a / a = ?_, _x / x = ?_ return: [6.0, 0.5, -1.0, 1.0, -1.0 ]
+
+**Example 2:**
+
+**Input:** equations = [["a","b"],["b","c"],["bc","cd"]], values = [1.5,2.5,5.0], queries = [["a","c"],["c","b"],["bc","cd"],["cd","bc"]]
+
+**Output:** [3.75000,0.40000,5.00000,0.20000]
+
+**Example 3:**
+
+**Input:** equations = [["a","b"]], values = [0.5], queries = [["a","b"],["b","a"],["a","c"],["x","y"]]
+
+**Output:** [0.50000,2.00000,-1.00000,-1.00000]
+
+**Constraints:**
+
+*   `1 <= equations.length <= 20`
+*   `equations[i].length == 2`
+*   <code>1 <= A<sub>i</sub>.length, B<sub>i</sub>.length <= 5</code>
+*   `values.length == equations.length`
+*   `0.0 < values[i] <= 20.0`
+*   `1 <= queries.length <= 20`
+*   `queries[i].length == 2`
+*   <code>1 <= C<sub>j</sub>.length, D<sub>j</sub>.length <= 5</code>
+*   <code>A<sub>i</sub>, B<sub>i</sub>, C<sub>j</sub>, D<sub>j</sub></code> consist of lower case English letters and digits.

src/main/kotlin/g0301_0400/s0400_nth_digit/Solution.kt

@@ -0,0 +1,27 @@
+package g0301_0400.s0400_nth_digit
+
+// #Medium #Math #Binary_Search #2022_11_29_Time_271_ms_(50.00%)_Space_33.7_MB_(50.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    /*
+    * 1. find the length of the number where the nth digit is from
+    * 2. find the actual number where the nth digit is from
+    * 3. find the nth digit and return
+    */
+    fun findNthDigit(n: Int): Int {
+        var n = n
+        var len = 1
+        var count: Long = 9
+        var start = 1
+        while (n > len * count) {
+            n -= (len * count).toInt()
+            len += 1
+            count *= 10
+            start *= 10
+        }
+        start += (n - 1) / len
+        val s = Integer.toString(start)
+        return Character.getNumericValue(s[(n - 1) % len])
+    }
+}

src/main/kotlin/g0301_0400/s0400_nth_digit/readme.md

@@ -0,0 +1,23 @@
+400\. Nth Digit
+
+Medium
+
+Given an integer `n`, return the <code>n<sup>th</sup></code> digit of the infinite integer sequence `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...]`.
+
+**Example 1:**
+
+**Input:** n = 3
+
+**Output:** 3
+
+**Example 2:**
+
+**Input:** n = 11
+
+**Output:** 0
+
+**Explanation:** The 11<sup>th</sup> digit of the sequence 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ... is a 0, which is part of the number 10.
+
+**Constraints:**
+
+*   <code>1 <= n <= 2<sup>31</sup> - 1</code>

src/test/kotlin/g0301_0400/s0396_rotate_function/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0301_0400.s0396_rotate_function
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun maxRotateFunction() {
+        assertThat(Solution().maxRotateFunction(intArrayOf(4, 3, 2, 6)), equalTo(26))
+    }
+
+    @Test
+    fun maxRotateFunction2() {
+        assertThat(Solution().maxRotateFunction(intArrayOf(100)), equalTo(0))
+    }
+}