Added tasks 900, 901, 902, 903

Author: ThanhNIT

README.md

@@ -1726,6 +1726,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
+| 0903 |[Valid Permutations for DI Sequence](src/main/kotlin/g0901_1000/s0903_valid_permutations_for_di_sequence/Solution.kt)| Hard | Dynamic_Programming | 140 | 100.00
+| 0902 |[Numbers At Most N Given Digit Set](src/main/kotlin/g0901_1000/s0902_numbers_at_most_n_given_digit_set/Solution.kt)| Hard | Array, Dynamic_Programming, Math, Binary_Search | 138 | 100.00
+| 0901 |[Online Stock Span](src/main/kotlin/g0901_1000/s0901_online_stock_span/StockSpanner.kt)| Medium | Stack, Design, Monotonic_Stack, Data_Stream | 641 | 75.00
+| 0900 |[RLE Iterator](src/main/kotlin/g0801_0900/s0900_rle_iterator/RLEIterator.kt)| Medium | Array, Design, Counting, Iterator | 175 | 83.33
 | 0899 |[Orderly Queue](src/main/kotlin/g0801_0900/s0899_orderly_queue/Solution.kt)| Hard | String, Math, Sorting | 148 | 100.00
 | 0898 |[Bitwise ORs of Subarrays](src/main/kotlin/g0801_0900/s0898_bitwise_ors_of_subarrays/Solution.kt)| Medium | Array, Dynamic_Programming, Bit_Manipulation | 812 | 100.00
 | 0897 |[Increasing Order Search Tree](src/main/kotlin/g0801_0900/s0897_increasing_order_search_tree/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree, Stack, Binary_Search_Tree | 128 | 85.71

src/main/kotlin/g0801_0900/s0900_rle_iterator/RLEIterator.kt

@@ -0,0 +1,35 @@
+package g0801_0900.s0900_rle_iterator
+
+// #Medium #Array #Design #Counting #Iterator
+// #2023_04_13_Time_175_ms_(83.33%)_Space_36.2_MB_(83.33%)
+
+@Suppress("NAME_SHADOWING")
+class RLEIterator(private val array: IntArray) {
+    private var index = 0
+    fun next(n: Int): Int {
+        var n = n
+        var lastElement = -1
+        while (n > 0 && index < array.size) {
+            if (array[index] > n) {
+                array[index] -= n
+                lastElement = array[index + 1]
+                break
+            } else if (array[index] == n) {
+                array[index] = 0
+                lastElement = array[index + 1]
+                index += 2
+                break
+            } else {
+                n -= array[index]
+                index += 2
+            }
+        }
+        return lastElement
+    }
+}
+
+/*
+ * Your RLEIterator object will be instantiated and called as such:
+ * var obj = RLEIterator(encoding)
+ * var param_1 = obj.next(n)
+ */

src/main/kotlin/g0801_0900/s0900_rle_iterator/readme.md

@@ -0,0 +1,41 @@
+900\. RLE Iterator
+
+Medium
+
+We can use run-length encoding (i.e., **RLE**) to encode a sequence of integers. In a run-length encoded array of even length `encoding` (**0-indexed**), for all even `i`, `encoding[i]` tells us the number of times that the non-negative integer value `encoding[i + 1]` is repeated in the sequence.
+
+*   For example, the sequence `arr = [8,8,8,5,5]` can be encoded to be `encoding = [3,8,2,5]`. `encoding = [3,8,0,9,2,5]` and `encoding = [2,8,1,8,2,5]` are also valid **RLE** of `arr`.
+
+Given a run-length encoded array, design an iterator that iterates through it.
+
+Implement the `RLEIterator` class:
+
+*   `RLEIterator(int[] encoded)` Initializes the object with the encoded array `encoded`.
+*   `int next(int n)` Exhausts the next `n` elements and returns the last element exhausted in this way. If there is no element left to exhaust, return `-1` instead.
+
+**Example 1:**
+
+**Input**
+
+["RLEIterator", "next", "next", "next", "next"]
+
+[[[3, 8, 0, 9, 2, 5]], [2], [1], [1], [2]]
+
+**Output:** [null, 8, 8, 5, -1]
+
+**Explanation:**
+
+    RLEIterator rLEIterator = new RLEIterator([3, 8, 0, 9, 2, 5]); // This maps to the sequence [8,8,8,5,5].
+    rLEIterator.next(2); // exhausts 2 terms of the sequence, returning 8. The remaining sequence is now [8, 5, 5].
+    rLEIterator.next(1); // exhausts 1 term of the sequence, returning 8. The remaining sequence is now [5, 5].
+    rLEIterator.next(1); // exhausts 1 term of the sequence, returning 5. The remaining sequence is now [5].
+    rLEIterator.next(2); // exhausts 2 terms, returning -1. This is because the first term exhausted was 5,
+    // but the second term did not exist. Since the last term exhausted does not exist, we return -1. 
+
+**Constraints:**
+
+*   `2 <= encoding.length <= 1000`
+*   `encoding.length` is even.
+*   <code>0 <= encoding[i] <= 10<sup>9</sup></code>
+*   <code>1 <= n <= 10<sup>9</sup></code>
+*   At most `1000` calls will be made to `next`.

src/main/kotlin/g0901_1000/s0901_online_stock_span/StockSpanner.kt

@@ -0,0 +1,39 @@
+package g0901_1000.s0901_online_stock_span
+
+// #Medium #Stack #Design #Monotonic_Stack #Data_Stream
+// #2023_04_13_Time_641_ms_(75.00%)_Space_66.5_MB_(10.71%)
+
+import java.util.Deque
+import java.util.LinkedList
+
+class StockSpanner {
+    private val map: MutableMap<Int, Int>
+    private val stocks: Deque<Int>
+    private var index: Int
+
+    init {
+        stocks = LinkedList()
+        index = -1
+        map = HashMap()
+        stocks.push(-1)
+    }
+
+    fun next(price: Int): Int {
+        if (index != -1) {
+            stocks.push(index)
+        }
+        map[++index] = price
+        if (stocks.size == 1) {
+            return index - stocks.peek()
+        }
+        while (stocks.size > 1 && map[stocks.peek()]!! <= price) {
+            stocks.pop()
+        }
+        return index - stocks.peek()
+    }
+}
+/*
+ * Your StockSpanner object will be instantiated and called as such:
+ * var obj = StockSpanner()
+ * var param_1 = obj.next(price)
+ */

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

@@ -0,0 +1,40 @@
+901\. Online Stock Span
+
+Medium
+
+Design an algorithm that collects daily price quotes for some stock and returns **the span** of that stock's price for the current day.
+
+The **span** of the stock's price today is defined as the maximum number of consecutive days (starting from today and going backward) for which the stock price was less than or equal to today's price.
+
+*   For example, if the price of a stock over the next `7` days were `[100,80,60,70,60,75,85]`, then the stock spans would be `[1,1,1,2,1,4,6]`.
+
+Implement the `StockSpanner` class:
+
+*   `StockSpanner()` Initializes the object of the class.
+*   `int next(int price)` Returns the **span** of the stock's price given that today's price is `price`.
+
+**Example 1:**
+
+**Input**
+
+["StockSpanner", "next", "next", "next", "next", "next", "next", "next"]
+
+[[], [100], [80], [60], [70], [60], [75], [85]]
+
+**Output:** [null, 1, 1, 1, 2, 1, 4, 6]
+
+**Explanation:**
+
+    StockSpanner stockSpanner = new StockSpanner(); 
+    stockSpanner.next(100); // return 1 
+    stockSpanner.next(80); // return 1 
+    stockSpanner.next(60); // return 1 
+    stockSpanner.next(70); // return 2 
+    stockSpanner.next(60); // return 1 
+    stockSpanner.next(75); // return 4, because the last 4 prices (including today's price of 75) were less than or equal to today's price. 
+    stockSpanner.next(85); // return 6
+
+**Constraints:**
+
+*   <code>1 <= price <= 10<sup>5</sup></code>
+*   At most <code>10<sup>4</sup></code> calls will be made to `next`.

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

@@ -0,0 +1,33 @@
+package g0901_1000.s0902_numbers_at_most_n_given_digit_set
+
+// #Hard #Array #Dynamic_Programming #Math #Binary_Search
+// #2023_04_13_Time_138_ms_(100.00%)_Space_33.7_MB_(100.00%)
+
+import kotlin.math.pow
+
+class Solution {
+    fun atMostNGivenDigitSet(digits: Array<String>, n: Int): Int {
+        var ans = 0
+        val num = "" + n
+        val d = digits.size
+        val l = num.length
+        for (i in 1 until l) {
+            ans += d.toDouble().pow(i.toDouble()).toInt()
+        }
+        for (i in 0 until l) {
+            var flag = false
+            for (digit in digits) {
+                if (digit[0] < num[i]) {
+                    ans += d.toDouble().pow((l - i - 1) * 1.0).toInt()
+                } else if (num[i] == digit[0]) {
+                    flag = true
+                    break
+                }
+            }
+            if (!flag) {
+                return ans
+            }
+        }
+        return ans + 1
+    }
+}

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

@@ -0,0 +1,38 @@
+902\. Numbers At Most N Given Digit Set
+
+Hard
+
+Given an array of `digits` which is sorted in **non-decreasing** order. You can write numbers using each `digits[i]` as many times as we want. For example, if `digits = ['1','3','5']`, we may write numbers such as `'13'`, `'551'`, and `'1351315'`.
+
+Return _the number of positive integers that can be generated_ that are less than or equal to a given integer `n`.
+
+**Example 1:**
+
+**Input:** digits = ["1","3","5","7"], n = 100
+
+**Output:** 20
+
+**Explanation:** The 20 numbers that can be written are: 1, 3, 5, 7, 11, 13, 15, 17, 31, 33, 35, 37, 51, 53, 55, 57, 71, 73, 75, 77.
+
+**Example 2:**
+
+**Input:** digits = ["1","4","9"], n = 1000000000
+
+**Output:** 29523
+
+**Explanation:** We can write 3 one digit numbers, 9 two digit numbers, 27 three digit numbers, 81 four digit numbers, 243 five digit numbers, 729 six digit numbers, 2187 seven digit numbers, 6561 eight digit numbers, and 19683 nine digit numbers. In total, this is 29523 integers that can be written using the digits array.
+
+**Example 3:**
+
+**Input:** digits = ["7"], n = 8
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= digits.length <= 9`
+*   `digits[i].length == 1`
+*   `digits[i]` is a digit from `'1'` to `'9'`.
+*   All the values in `digits` are **unique**.
+*   `digits` is sorted in **non-decreasing** order.
+*   <code>1 <= n <= 10<sup>9</sup></code>

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

@@ -0,0 +1,29 @@
+package g0901_1000.s0903_valid_permutations_for_di_sequence
+
+// #Hard #Dynamic_Programming #2023_04_13_Time_140_ms_(100.00%)_Space_34.9_MB_(100.00%)
+
+class Solution {
+    fun numPermsDISequence(s: String): Int {
+        val n = s.length
+        val mod = 1e9.toInt() + 7
+        val dp = Array(n + 1) { IntArray(n + 1) }
+        for (j in 0..n) {
+            dp[0][j] = 1
+        }
+        for (i in 0 until n) {
+            var cur = 0
+            if (s[i] == 'I') {
+                for (j in 0 until n - i) {
+                    cur = (cur + dp[i][j]) % mod
+                    dp[i + 1][j] = cur
+                }
+            } else {
+                for (j in n - i - 1 downTo 0) {
+                    cur = (cur + dp[i][j + 1]) % mod
+                    dp[i + 1][j] = cur
+                }
+            }
+        }
+        return dp[n][0]
+    }
+}

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

@@ -0,0 +1,41 @@
+903\. Valid Permutations for DI Sequence
+
+Hard
+
+You are given a string `s` of length `n` where `s[i]` is either:
+
+*   `'D'` means decreasing, or
+*   `'I'` means increasing.
+
+A permutation `perm` of `n + 1` integers of all the integers in the range `[0, n]` is called a **valid permutation** if for all valid `i`:
+
+*   If `s[i] == 'D'`, then `perm[i] > perm[i + 1]`, and
+*   If `s[i] == 'I'`, then `perm[i] < perm[i + 1]`.
+
+Return _the number of **valid permutations**_ `perm`. Since the answer may be large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** s = "DID"
+
+**Output:** 5
+
+**Explanation:** The 5 valid permutations of (0, 1, 2, 3) are: 
+
+    (1, 0, 3, 2) 
+    (2, 0, 3, 1) 
+    (2, 1, 3, 0) 
+    (3, 0, 2, 1) 
+    (3, 1, 2, 0)
+
+**Example 2:**
+
+**Input:** s = "D"
+
+**Output:** 1
+
+**Constraints:**
+
+*   `n == s.length`
+*   `1 <= n <= 200`
+*   `s[i]` is either `'I'` or `'D'`.

src/test/kotlin/g0801_0900/s0900_rle_iterator/RLEIteratorTest.kt

@@ -0,0 +1,16 @@
+package g0801_0900.s0900_rle_iterator
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class RLEIteratorTest {
+    @Test
+    fun rleIteratorTest() {
+        val rleIterator = RLEIterator(intArrayOf(3, 8, 0, 9, 2, 5))
+        assertThat(rleIterator.next(2), equalTo(8))
+        assertThat(rleIterator.next(1), equalTo(8))
+        assertThat(rleIterator.next(1), equalTo(5))
+        assertThat(rleIterator.next(2), equalTo(-1))
+    }
+}