Added tasks 712, 713, 714, 715

Author: ThanhNIT

README.md

@@ -126,6 +126,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0438 |[Find All Anagrams in a String](src.save/main/kotlin/g0401_0500/s0438_find_all_anagrams_in_a_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Sliding_Window | 561 | 54.68
+| 0713 |[Subarray Product Less Than K](src/main/kotlin/g0701_0800/s0713_subarray_product_less_than_k/Solution.kt)| Medium | Array, Sliding_Window | 336 | 92.11
 
 #### Day 13
 
@@ -625,6 +626,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | 0041 |[First Missing Positive](src.save/main/kotlin/g0001_0100/s0041_first_missing_positive/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table | 345 | 100.00
 | 0697 |[Degree of an Array](src/main/kotlin/g0601_0700/s0697_degree_of_an_array/Solution.kt)| Easy | Array, Hash_Table | 289 | 84.62
 | 0532 |[K-diff Pairs in an Array](src.save/main/kotlin/g0501_0600/s0532_k_diff_pairs_in_an_array/Solution.kt)| Medium | Array, Hash_Table, Sorting, Binary_Search, Two_Pointers | 230 | 84.62
+| 0713 |[Subarray Product Less Than K](src/main/kotlin/g0701_0800/s0713_subarray_product_less_than_k/Solution.kt)| Medium | Array, Sliding_Window | 336 | 92.11
 | 0456 |[132 Pattern](src.save/main/kotlin/g0401_0500/s0456_132_pattern/Solution.kt)| Medium | Array, Binary_Search, Stack, Ordered_Set, Monotonic_Stack | 434 | 100.00
 | 0239 |[Sliding Window Maximum](src.save/main/kotlin/g0201_0300/s0239_sliding_window_maximum/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Heap_Priority_Queue, Sliding_Window, Queue, Monotonic_Queue | 1059 | 86.14
 
@@ -1157,6 +1159,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0438 |[Find All Anagrams in a String](src.save/main/kotlin/g0401_0500/s0438_find_all_anagrams_in_a_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Sliding_Window | 561 | 54.68
+| 0713 |[Subarray Product Less Than K](src/main/kotlin/g0701_0800/s0713_subarray_product_less_than_k/Solution.kt)| Medium | Array, Sliding_Window | 336 | 92.11
 | 0209 |[Minimum Size Subarray Sum](src.save/main/kotlin/g0201_0300/s0209_minimum_size_subarray_sum/Solution.kt)| Medium | Array, Binary_Search, Prefix_Sum, Sliding_Window | 315 | 96.73
 
 #### Day 6 Breadth First Search Depth First Search
@@ -1515,6 +1518,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0309 |[Best Time to Buy and Sell Stock with Cooldown](src.save/main/kotlin/g0301_0400/s0309_best_time_to_buy_and_sell_stock_with_cooldown/Solution.kt)| Medium | Array, Dynamic_Programming | 272 | 73.33
+| 0714 |[Best Time to Buy and Sell Stock with Transaction Fee](src/main/kotlin/g0701_0800/s0714_best_time_to_buy_and_sell_stock_with_transaction_fee/Solution.kt)| Medium | Array, Dynamic_Programming, Greedy | 417 | 90.91
 
 #### Day 9
 
@@ -1692,6 +1696,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | 0864 |[Shortest Path to Get All Keys](src/main/kotlin/g0801_0900/s0864_shortest_path_to_get_all_keys/Solution.kt)| Hard | Breadth_First_Search, Bit_Manipulation | 176 | 100.00
 | 0763 |[Partition Labels](src/main/kotlin/g0701_0800/s0763_partition_labels/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Greedy, Two_Pointers, Data_Structure_II_Day_7_String | 235 | 84.75
 | 0739 |[Daily Temperatures](src/main/kotlin/g0701_0800/s0739_daily_temperatures/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Stack, Monotonic_Stack, Programming_Skills_II_Day_6 | 936 | 80.54
+| 0715 |[Range Module](src/main/kotlin/g0701_0800/s0715_range_module/RangeModule.kt)| Hard | Design, Ordered_Set, Segment_Tree | 638 | 58.33
+| 0714 |[Best Time to Buy and Sell Stock with Transaction Fee](src/main/kotlin/g0701_0800/s0714_best_time_to_buy_and_sell_stock_with_transaction_fee/Solution.kt)| Medium | Array, Dynamic_Programming, Greedy, Dynamic_Programming_I_Day_8 | 417 | 90.91
+| 0713 |[Subarray Product Less Than K](src/main/kotlin/g0701_0800/s0713_subarray_product_less_than_k/Solution.kt)| Medium | Array, Sliding_Window, Algorithm_II_Day_5_Sliding_Window, Programming_Skills_II_Day_12, Udemy_Arrays | 336 | 92.11
+| 0712 |[Minimum ASCII Delete Sum for Two Strings](src/main/kotlin/g0701_0800/s0712_minimum_ascii_delete_sum_for_two_strings/Solution.kt)| Medium | String, Dynamic_Programming | 176 | 100.00
 | 0710 |[Random Pick with Blacklist](src/main/kotlin/g0701_0800/s0710_random_pick_with_blacklist/Solution.kt)| Hard | Hash_Table, Math, Sorting, Binary_Search, Randomized | 632 | 100.00
 | 0709 |[To Lower Case](src/main/kotlin/g0701_0800/s0709_to_lower_case/Solution.kt)| Easy | String, Programming_Skills_I_Day_9_String | 142 | 98.68
 | 0707 |[Design Linked List](src/main/kotlin/g0701_0800/s0707_design_linked_list/MyLinkedList.kt)| Medium | Design, Linked_List, Data_Structure_II_Day_12_Linked_List, Programming_Skills_II_Day_19, Udemy_Linked_List | 243 | 100.00

src/main/kotlin/g0701_0800/s0712_minimum_ascii_delete_sum_for_two_strings/Solution.kt

@@ -0,0 +1,31 @@
+package g0701_0800.s0712_minimum_ascii_delete_sum_for_two_strings
+
+// #Medium #String #Dynamic_Programming #2023_02_25_Time_176_ms_(100.00%)_Space_36.9_MB_(58.33%)
+
+class Solution {
+    fun minimumDeleteSum(s1: String, s2: String): Int {
+        val len1 = s1.length
+        val len2 = s2.length
+        val dp = Array(len1 + 1) { IntArray(len2 + 1) }
+        var c1: Char
+        var c2: Char
+        for (i in 1 until len1 + 1) {
+            dp[i][0] = dp[i - 1][0] + s1[i - 1].code
+        }
+        for (j in 1 until len2 + 1) {
+            dp[0][j] = dp[0][j - 1] + s2[j - 1].code
+        }
+        for (i in 1 until len1 + 1) {
+            c1 = s1[i - 1]
+            for (j in 1 until len2 + 1) {
+                c2 = s2[j - 1]
+                if (c1 == c2) {
+                    dp[i][j] = dp[i - 1][j - 1]
+                } else {
+                    dp[i][j] = (dp[i - 1][j] + c1.code).coerceAtMost(dp[i][j - 1] + c2.code)
+                }
+            }
+        }
+        return dp[len1][len2]
+    }
+}

src/main/kotlin/g0701_0800/s0712_minimum_ascii_delete_sum_for_two_strings/readme.md

@@ -0,0 +1,26 @@
+712\. Minimum ASCII Delete Sum for Two Strings
+
+Medium
+
+Given two strings `s1` and `s2`, return _the lowest **ASCII** sum of deleted characters to make two strings equal_.
+
+**Example 1:**
+
+**Input:** s1 = "sea", s2 = "eat"
+
+**Output:** 231
+
+**Explanation:** Deleting "s" from "sea" adds the ASCII value of "s" (115) to the sum. Deleting "t" from "eat" adds 116 to the sum. At the end, both strings are equal, and 115 + 116 = 231 is the minimum sum possible to achieve this.
+
+**Example 2:**
+
+**Input:** s1 = "delete", s2 = "leet"
+
+**Output:** 403
+
+**Explanation:** Deleting "dee" from "delete" to turn the string into "let", adds 100[d] + 101[e] + 101[e] to the sum. Deleting "e" from "leet" adds 101[e] to the sum. At the end, both strings are equal to "let", and the answer is 100+101+101+101 = 403. If instead we turned both strings into "lee" or "eet", we would get answers of 433 or 417, which are higher.
+
+**Constraints:**
+
+*   `1 <= s1.length, s2.length <= 1000`
+*   `s1` and `s2` consist of lowercase English letters.

src/main/kotlin/g0701_0800/s0713_subarray_product_less_than_k/Solution.kt

@@ -0,0 +1,21 @@
+package g0701_0800.s0713_subarray_product_less_than_k
+
+// #Medium #Array #Sliding_Window #Algorithm_II_Day_5_Sliding_Window #Programming_Skills_II_Day_12
+// #Udemy_Arrays #2023_02_25_Time_336_ms_(92.11%)_Space_42_MB_(94.74%)
+
+class Solution {
+    fun numSubarrayProductLessThanK(nums: IntArray, k: Int): Int {
+        var p = 1
+        var j = 0
+        var ans = 0
+        for (i in nums.indices) {
+            p *= nums[i]
+            while (p >= k && j < i) {
+                p /= nums[j]
+                j++
+            }
+            ans += if (p < k) i - j + 1 else 0
+        }
+        return ans
+    }
+}

src/main/kotlin/g0701_0800/s0713_subarray_product_less_than_k/readme.md

@@ -0,0 +1,25 @@
+713\. Subarray Product Less Than K
+
+Medium
+
+Given an array of integers `nums` and an integer `k`, return _the number of contiguous subarrays where the product of all the elements in the subarray is strictly less than_ `k`.
+
+**Example 1:**
+
+**Input:** nums = [10,5,2,6], k = 100
+
+**Output:** 8
+
+**Explanation:** The 8 subarrays that have product less than 100 are: [10], [5], [2], [6], [10, 5], [5, 2], [2, 6], [5, 2, 6] Note that [10, 5, 2] is not included as the product of 100 is not strictly less than k.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3], k = 0
+
+**Output:** 0
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 3 * 10<sup>4</sup></code>
+*   `1 <= nums[i] <= 1000`
+*   <code>0 <= k <= 10<sup>6</sup></code>

src/main/kotlin/g0701_0800/s0714_best_time_to_buy_and_sell_stock_with_transaction_fee/Solution.kt

@@ -0,0 +1,16 @@
+package g0701_0800.s0714_best_time_to_buy_and_sell_stock_with_transaction_fee
+
+// #Medium #Array #Dynamic_Programming #Greedy #Dynamic_Programming_I_Day_8
+// #2023_02_25_Time_417_ms_(90.91%)_Space_46.1_MB_(75.00%)
+
+class Solution {
+    fun maxProfit(prices: IntArray, fee: Int): Int {
+        var cash = 0
+        var hold = -prices[0]
+        for (i in 1 until prices.size) {
+            cash = cash.coerceAtLeast(hold + prices[i] - fee)
+            hold = hold.coerceAtLeast(cash - prices[i])
+        }
+        return cash
+    }
+}

src/main/kotlin/g0701_0800/s0714_best_time_to_buy_and_sell_stock_with_transaction_fee/readme.md

@@ -0,0 +1,39 @@
+714\. Best Time to Buy and Sell Stock with Transaction Fee
+
+Medium
+
+You are given an array `prices` where `prices[i]` is the price of a given stock on the <code>i<sup>th</sup></code> day, and an integer `fee` representing a transaction fee.
+
+Find the maximum profit you can achieve. You may complete as many transactions as you like, but you need to pay the transaction fee for each transaction.
+
+**Note:** You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).
+
+**Example 1:**
+
+**Input:** prices = [1,3,2,8,4,9], fee = 2
+
+**Output:** 8
+
+**Explanation:** The maximum profit can be achieved by: 
+
+- Buying at prices[0] = 1 
+
+- Selling at prices[3] = 8 
+
+- Buying at prices[4] = 4 
+
+- Selling at prices[5] = 9 
+
+The total profit is ((8 - 1) - 2) + ((9 - 4) - 2) = 8.
+
+**Example 2:**
+
+**Input:** prices = [1,3,7,5,10,3], fee = 3
+
+**Output:** 6
+
+**Constraints:**
+
+*   <code>1 <= prices.length <= 5 * 10<sup>4</sup></code>
+*   <code>1 <= prices[i] < 5 * 10<sup>4</sup></code>
+*   <code>0 <= fee < 5 * 10<sup>4</sup></code>

src/main/kotlin/g0701_0800/s0715_range_module/RangeModule.kt

@@ -0,0 +1,84 @@
+package g0701_0800.s0715_range_module
+
+// #Hard #Design #Ordered_Set #Segment_Tree #2023_02_25_Time_638_ms_(58.33%)_Space_60.4_MB_(66.67%)
+
+@Suppress("NAME_SHADOWING")
+class RangeModule {
+    private val head: Interval = Interval(0, 0)
+
+    fun addRange(left: Int, right: Int) {
+        var left = left
+        var right = right
+        var pos: Interval? = head
+        while (pos!!.next != null && pos.next!!.end < left) {
+            pos = pos.next
+        }
+        while (pos.next != null && pos.next!!.start <= right) {
+            left = pos.next!!.start.coerceAtMost(left)
+            right = pos.next!!.end.coerceAtLeast(right)
+            removeNext(pos)
+        }
+        insert(pos, Interval(left, right))
+    }
+
+    fun queryRange(left: Int, right: Int): Boolean {
+        var pos: Interval? = head
+        while (pos != null) {
+            if (left >= pos.start && right <= pos.end) {
+                return true
+            }
+            pos = pos.next
+        }
+        return false
+    }
+
+    fun removeRange(left: Int, right: Int) {
+        var pos: Interval? = head
+        while (pos!!.next != null && pos.next!!.end <= left) {
+            pos = pos.next
+        }
+        var prev = pos
+        var curr = pos.next
+        while (curr != null && curr.start < right) {
+            if (curr.start < left) {
+                insert(prev, Interval(curr.start, left))
+                curr.start = left
+                prev = prev!!.next
+                curr = prev!!.next
+                continue
+            }
+            if (right >= curr.end) {
+                removeNext(prev)
+                curr = prev!!.next
+            } else {
+                curr.start = right
+                curr = curr.next
+            }
+        }
+    }
+
+    private fun insert(curr: Interval?, next: Interval) {
+        next.next = curr!!.next
+        curr.next = next
+    }
+
+    private fun removeNext(curr: Interval?) {
+        val del = curr!!.next
+        if (del != null) {
+            curr.next = del.next
+            del.next = null
+        }
+    }
+
+    internal class Interval(var start: Int, var end: Int) {
+        var next: Interval? = null
+    }
+}
+
+/*
+ * Your RangeModule object will be instantiated and called as such:
+ * var obj = RangeModule()
+ * obj.addRange(left,right)
+ * var param_2 = obj.queryRange(left,right)
+ * obj.removeRange(left,right)
+ */

src/main/kotlin/g0701_0800/s0715_range_module/readme.md

@@ -0,0 +1,38 @@
+715\. Range Module
+
+Hard
+
+A Range Module is a module that tracks ranges of numbers. Design a data structure to track the ranges represented as **half-open intervals** and query about them.
+
+A **half-open interval** `[left, right)` denotes all the real numbers `x` where `left <= x < right`.
+
+Implement the `RangeModule` class:
+
+*   `RangeModule()` Initializes the object of the data structure.
+*   `void addRange(int left, int right)` Adds the **half-open interval** `[left, right)`, tracking every real number in that interval. Adding an interval that partially overlaps with currently tracked numbers should add any numbers in the interval `[left, right)` that are not already tracked.
+*   `boolean queryRange(int left, int right)` Returns `true` if every real number in the interval `[left, right)` is currently being tracked, and `false` otherwise.
+*   `void removeRange(int left, int right)` Stops tracking every real number currently being tracked in the **half-open interval** `[left, right)`.
+
+**Example 1:**
+
+**Input**
+
+["RangeModule", "addRange", "removeRange", "queryRange", "queryRange", "queryRange"]
+
+[[], [10, 20], [14, 16], [10, 14], [13, 15], [16, 17]]
+
+**Output:** [null, null, null, true, false, true]
+
+**Explanation:**
+
+    RangeModule rangeModule = new RangeModule();
+    rangeModule.addRange(10, 20); 
+    rangeModule.removeRange(14, 16); 
+    rangeModule.queryRange(10, 14); // return True,(Every number in [10, 14) is being tracked) 
+    rangeModule.queryRange(13, 15); // return False,(Numbers like 14, 14.03, 14.17 in [13, 15) are not being tracked) 
+    rangeModule.queryRange(16, 17); // return True, (The number 16 in [16, 17) is still being tracked, despite the remove operation)
+
+**Constraints:**
+
+*   <code>1 <= left < right <= 10<sup>9</sup></code>
+*   At most <code>10<sup>4</sup></code> calls will be made to `addRange`, `queryRange`, and `removeRange`.

src/test/kotlin/g0701_0800/s0712_minimum_ascii_delete_sum_for_two_strings/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0701_0800.s0712_minimum_ascii_delete_sum_for_two_strings
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun minimumDeleteSum() {
+        assertThat(Solution().minimumDeleteSum("sea", "eat"), equalTo(231))
+    }
+
+    @Test
+    fun minimumDeleteSum2() {
+        assertThat(Solution().minimumDeleteSum("delete", "leet"), equalTo(403))
+    }
+}