Added tasks 904, 905, 906, 907

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
+| 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
+| 0904 |[Fruit Into Baskets](src/main/kotlin/g0901_1000/s0904_fruit_into_baskets/Solution.kt)| Medium | Array, Hash_Table, Sliding_Window | 371 | 100.00
 | 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

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

@@ -0,0 +1,38 @@
+package g0901_1000.s0904_fruit_into_baskets
+
+// #Medium #Array #Hash_Table #Sliding_Window #2023_04_14_Time_371_ms_(100.00%)_Space_46_MB_(87.50%)
+
+class Solution {
+    fun totalFruit(fruits: IntArray): Int {
+        var end = 1
+        var basket1 = fruits[0]
+        var basket2 = -1
+        var secondFruitIndex = -1
+        var maxTotal = 1
+        var counter = 1
+        while (end < fruits.size) {
+            if (fruits[end - 1] != fruits[end]) {
+                if (basket2 == -1) {
+                    basket2 = fruits[end]
+                    secondFruitIndex = end
+                    counter++
+                } else if (fruits[end] == basket1) {
+                    basket1 = basket2
+                    basket2 = fruits[end]
+                    secondFruitIndex = end
+                    counter++
+                } else {
+                    counter = end - secondFruitIndex + 1
+                    basket1 = basket2
+                    basket2 = fruits[end]
+                    secondFruitIndex = end
+                }
+            } else {
+                counter++
+            }
+            end++
+            maxTotal = maxTotal.coerceAtLeast(counter)
+        }
+        return maxTotal
+    }
+}

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

@@ -0,0 +1,42 @@
+904\. Fruit Into Baskets
+
+Medium
+
+You are visiting a farm that has a single row of fruit trees arranged from left to right. The trees are represented by an integer array `fruits` where `fruits[i]` is the **type** of fruit the <code>i<sup>th</sup></code> tree produces.
+
+You want to collect as much fruit as possible. However, the owner has some strict rules that you must follow:
+
+*   You only have **two** baskets, and each basket can only hold a **single type** of fruit. There is no limit on the amount of fruit each basket can hold.
+*   Starting from any tree of your choice, you must pick **exactly one fruit** from **every** tree (including the start tree) while moving to the right. The picked fruits must fit in one of your baskets.
+*   Once you reach a tree with fruit that cannot fit in your baskets, you must stop.
+
+Given the integer array `fruits`, return _the **maximum** number of fruits you can pick_.
+
+**Example 1:**
+
+**Input:** fruits = [<ins>1,2,1</ins>]
+
+**Output:** 3
+
+**Explanation:** We can pick from all 3 trees.
+
+**Example 2:**
+
+**Input:** fruits = [0,<ins>1,2,2</ins>]
+
+**Output:** 3
+
+**Explanation:** We can pick from trees [1,2,2]. If we had started at the first tree, we would only pick from trees [0,1].
+
+**Example 3:**
+
+**Input:** fruits = [1,<ins>2,3,2,2</ins>]
+
+**Output:** 4
+
+**Explanation:** We can pick from trees [2,3,2,2]. If we had started at the first tree, we would only pick from trees [1,2].
+
+**Constraints:**
+
+*   <code>1 <= fruits.length <= 10<sup>5</sup></code>
+*   `0 <= fruits[i] < fruits.length`

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

@@ -0,0 +1,19 @@
+package g0901_1000.s0905_sort_array_by_parity
+
+// #Easy #Array #Sorting #Two_Pointers #2023_04_14_Time_219_ms_(75.00%)_Space_36.7_MB_(100.00%)
+
+class Solution {
+    fun sortArrayByParity(nums: IntArray): IntArray {
+        var temp: Int
+        var i = 0
+        for (k in nums.indices) {
+            if (nums[k] % 2 == 0) {
+                temp = nums[k]
+                nums[k] = nums[i]
+                nums[i] = temp
+                i++
+            }
+        }
+        return nums
+    }
+}

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

@@ -0,0 +1,26 @@
+905\. Sort Array By Parity
+
+Easy
+
+Given an integer array `nums`, move all the even integers at the beginning of the array followed by all the odd integers.
+
+Return _**any array** that satisfies this condition_.
+
+**Example 1:**
+
+**Input:** nums = [3,1,2,4]
+
+**Output:** [2,4,3,1]
+
+**Explanation:** The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.
+
+**Example 2:**
+
+**Input:** nums = [0]
+
+**Output:** [0]
+
+**Constraints:**
+
+*   `1 <= nums.length <= 5000`
+*   `0 <= nums[i] <= 5000`

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

@@ -0,0 +1,63 @@
+package g0901_1000.s0906_super_palindromes
+
+// #Hard #Math #Enumeration #2023_04_14_Time_153_ms_(100.00%)_Space_33.1_MB_(100.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun superpalindromesInRange(left: String, right: String): Int {
+        val l = left.toLong()
+        val r = right.toLong()
+        var cnt = 0
+        var cur: Long = 1
+        while (true) {
+            val p1 = getPalindromeIncLastDigit(cur)
+            val p2 = getPalindromeExcLastDigit(cur)
+            val sq1 = p1 * p1
+            val sq2 = p2 * p2
+            if (sq2 > r) {
+                break
+            }
+            if (sq1 in l..r && isPalindrome(sq1)) {
+                cnt++
+            }
+            if (sq2 >= l && isPalindrome(sq2)) {
+                cnt++
+            }
+            cur++
+        }
+        return cnt
+    }
+
+    private fun isPalindrome(`val`: Long): Boolean {
+        var `val` = `val`
+        var construct: Long = 0
+        if (`val` % 10 == 0L && `val` >= 10) {
+            return false
+        }
+        while (construct < `val`) {
+            construct = construct * 10 + `val` % 10
+            `val` /= 10
+        }
+        return construct == `val` || construct / 10 == `val`
+    }
+
+    private fun getPalindromeIncLastDigit(`val`: Long): Long {
+        var `val` = `val`
+        var copy = `val`
+        while (copy != 0L) {
+            `val` = `val` * 10 + copy % 10
+            copy /= 10
+        }
+        return `val`
+    }
+
+    private fun getPalindromeExcLastDigit(`val`: Long): Long {
+        var `val` = `val`
+        var copy = `val` / 10
+        while (copy != 0L) {
+            `val` = `val` * 10 + copy % 10
+            copy /= 10
+        }
+        return `val`
+    }
+}

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

@@ -0,0 +1,29 @@
+906\. Super Palindromes
+
+Hard
+
+Let's say a positive integer is a **super-palindrome** if it is a palindrome, and it is also the square of a palindrome.
+
+Given two positive integers `left` and `right` represented as strings, return _the number of **super-palindromes** integers in the inclusive range_ `[left, right]`.
+
+**Example 1:**
+
+**Input:** left = "4", right = "1000"
+
+**Output:** 4
+
+**Explanation:**: 4, 9, 121, and 484 are superpalindromes. Note that 676 is not a superpalindrome: 26 \* 26 = 676, but 26 is not a palindrome.
+
+**Example 2:**
+
+**Input:** left = "1", right = "2"
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= left.length, right.length <= 18`
+*   `left` and `right` consist of only digits.
+*   `left` and `right` cannot have leading zeros.
+*   `left` and `right` represent integers in the range <code>[1, 10<sup>18</sup> - 1]</code>.
+*   `left` is less than or equal to `right`.

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

@@ -0,0 +1,49 @@
+package g0901_1000.s0907_sum_of_subarray_minimums
+
+// #Medium #Array #Dynamic_Programming #Stack #Monotonic_Stack
+// #2023_04_14_Time_341_ms_(100.00%)_Space_44.3_MB_(100.00%)
+
+class Solution {
+    private fun calculateRight(i: Int, start: Int, right: IntArray, arr: IntArray, len: Int): Int {
+        if (start >= len) {
+            return 0
+        }
+        return if (arr[start] < arr[i]) {
+            0
+        } else (1 + right[start] + calculateRight(i, start + right[start] + 1, right, arr, len)) % MOD
+    }
+
+    private fun calculateLeft(i: Int, start: Int, left: IntArray, arr: IntArray, len: Int): Int {
+        if (start < 0) {
+            return 0
+        }
+        return if (arr[start] <= arr[i]) {
+            0
+        } else (1 + left[start] + calculateLeft(i, start - left[start] - 1, left, arr, len)) % MOD
+    }
+
+    fun sumSubarrayMins(arr: IntArray): Int {
+        val len = arr.size
+        val right = IntArray(len)
+        val left = IntArray(len)
+        right[len - 1] = 0
+        for (i in len - 2 downTo 0) {
+            right[i] = calculateRight(i, i + 1, right, arr, len)
+        }
+        left[0] = 0
+        for (i in 1 until len) {
+            left[i] = calculateLeft(i, i - 1, left, arr, len)
+        }
+        var answer = 0
+        for (i in 0 until len) {
+            val model: Long = 1000000007
+            answer += ((1 + left[i]) * (1 + right[i]).toLong() % model * arr[i] % model).toInt()
+            answer %= MOD
+        }
+        return answer
+    }
+
+    companion object {
+        private const val MOD = 1000000007
+    }
+}

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

@@ -0,0 +1,30 @@
+907\. Sum of Subarray Minimums
+
+Medium
+
+Given an array of integers arr, find the sum of `min(b)`, where `b` ranges over every (contiguous) subarray of `arr`. Since the answer may be large, return the answer **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** arr = [3,1,2,4]
+
+**Output:** 17
+
+**Explanation:** 
+
+Subarrays are [3], [1], [2], [4], [3,1], [1,2], [2,4], [3,1,2], [1,2,4], [3,1,2,4]. 
+
+Minimums are 3, 1, 2, 4, 1, 1, 2, 1, 1, 1. 
+
+Sum is 17.
+
+**Example 2:**
+
+**Input:** arr = [11,81,94,43,3]
+
+**Output:** 444
+
+**Constraints:**
+
+*   <code>1 <= arr.length <= 3 * 10<sup>4</sup></code>
+*   <code>1 <= arr[i] <= 3 * 10<sup>4</sup></code>

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

@@ -0,0 +1,22 @@
+package g0901_1000.s0904_fruit_into_baskets
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun totalFruit() {
+        assertThat(Solution().totalFruit(intArrayOf(1, 2, 1)), equalTo(3))
+    }
+
+    @Test
+    fun totalFruit2() {
+        assertThat(Solution().totalFruit(intArrayOf(0, 1, 2, 2)), equalTo(3))
+    }
+
+    @Test
+    fun totalFruit3() {
+        assertThat(Solution().totalFruit(intArrayOf(1, 2, 3, 2, 2)), equalTo(4))
+    }
+}