Added tasks 1103-1148

Author: javadev

README.md

@@ -1212,6 +1212,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 1146 |[Snapshot Array](src/main/kotlin/g1101_1200/s1146_snapshot_array/SnapshotArray.kt)| Medium | Array, Hash_Table, Binary_Search, Design | 1064 | 57.14
 
 #### Day 19
 
@@ -1231,6 +1232,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0509 |[Fibonacci Number](src/main/kotlin/g0501_0600/s0509_fibonacci_number/Solution.kt)| Easy | Dynamic_Programming, Math, Recursion, Memoization | 139 | 82.72
+| 1137 |[N-th Tribonacci Number](src/main/kotlin/g1101_1200/s1137_n_th_tribonacci_number/Solution.kt)| Easy | Dynamic_Programming, Math, Memoization | 122 | 69.35
 
 #### Day 2
 
@@ -1653,6 +1655,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 1129 |[Shortest Path with Alternating Colors](src/main/kotlin/g1101_1200/s1129_shortest_path_with_alternating_colors/Solution.kt)| Medium | Breadth_First_Search, Graph | 241 | 16.67
 | 0847 |[Shortest Path Visiting All Nodes](src/main/kotlin/g0801_0900/s0847_shortest_path_visiting_all_nodes/Solution.kt)| Hard | Dynamic_Programming, Breadth_First_Search, Bit_Manipulation, Graph, Bitmask | 164 | 100.00
 
 #### Day 11 Breadth First Search
@@ -1716,6 +1719,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0175 |[Combine Two Tables](src/main/kotlin/g0101_0200/s0175_combine_two_tables/script.sql)| Easy | Database | 473 | 54.97
+| 1148 |[Article Views I](src/main/kotlin/g1101_1200/s1148_article_views_i/script.sql)| Easy | LeetCode_Curated_SQL_70, Database | 806 | 54.41
 
 #### Day 6 Union
 
@@ -1728,6 +1732,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 1141 |[User Activity for the Past 30 Days I](src/main/kotlin/g1101_1200/s1141_user_activity_for_the_past_30_days_i/script.sql)| Easy | LeetCode_Curated_SQL_70, Database | 790 | 87.11
 
 #### Day 8 Function
 
@@ -1754,7 +1759,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
 | 1200 |[Minimum Absolute Difference](src/main/kotlin/g1101_1200/s1200_minimum_absolute_difference/Solution.kt)| Easy | Array, Sorting | 507 | 75.00
-| 1195 |[Fizz Buzz Multithreaded](src/main/kotlin/g1101_1200/s1195_fizz_buzz_multithreaded/FizzBuzz.kt)| Medium ||  | 
+| 1195 |[Fizz Buzz Multithreaded](src/main/kotlin/g1101_1200/s1195_fizz_buzz_multithreaded/FizzBuzz.kt)| Medium | Concurrency | 6 | 87.26
 | 1192 |[Critical Connections in a Network](src/main/kotlin/g1101_1200/s1192_critical_connections_in_a_network/Solution.kt)| Hard | Depth_First_Search, Graph, Biconnected_Component | 1696 | 60.00
 | 1191 |[K-Concatenation Maximum Sum](src/main/kotlin/g1101_1200/s1191_k_concatenation_maximum_sum/Solution.kt)| Medium | Array, Dynamic_Programming | 389 | 100.00
 | 1190 |[Reverse Substrings Between Each Pair of Parentheses](src/main/kotlin/g1101_1200/s1190_reverse_substrings_between_each_pair_of_parentheses/Solution.kt)| Medium | String, Stack | 153 | 42.86
@@ -1780,7 +1785,37 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 | 1156 |[Swap For Longest Repeated Character Substring](src/main/kotlin/g1101_1200/s1156_swap_for_longest_repeated_character_substring/Solution.kt)| Medium | String, Sliding_Window | 195 | 20.00
 | 1155 |[Number of Dice Rolls With Target Sum](src/main/kotlin/g1101_1200/s1155_number_of_dice_rolls_with_target_sum/Solution.kt)| Medium | Dynamic_Programming | 158 | 80.95
 | 1154 |[Day of the Year](src/main/kotlin/g1101_1200/s1154_day_of_the_year/Solution.kt)| Easy | String, Math | 317 | 70.00
+| 1148 |[Article Views I](src/main/kotlin/g1101_1200/s1148_article_views_i/script.sql)| Easy | LeetCode_Curated_SQL_70, Database, SQL_I_Day_5_Union | 806 | 54.41
+| 1147 |[Longest Chunked Palindrome Decomposition](src/main/kotlin/g1101_1200/s1147_longest_chunked_palindrome_decomposition/Solution.kt)| Hard | String, Dynamic_Programming, Greedy, Two_Pointers, Hash_Function, Rolling_Hash | 148 | 50.00
+| 1146 |[Snapshot Array](src/main/kotlin/g1101_1200/s1146_snapshot_array/SnapshotArray.kt)| Medium | Array, Hash_Table, Binary_Search, Design, Binary_Search_II_Day_18 | 1064 | 57.14
+| 1145 |[Binary Tree Coloring Game](src/main/kotlin/g1101_1200/s1145_binary_tree_coloring_game/Solution.kt)| Medium | Depth_First_Search, Tree, Binary_Tree | 181 | 100.00
+| 1144 |[Decrease Elements To Make Array Zigzag](src/main/kotlin/g1101_1200/s1144_decrease_elements_to_make_array_zigzag/Solution.kt)| Medium | Array, Greedy | 144 | 100.00
 | 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
+| 1141 |[User Activity for the Past 30 Days I](src/main/kotlin/g1101_1200/s1141_user_activity_for_the_past_30_days_i/script.sql)| Easy | LeetCode_Curated_SQL_70, Database, SQL_I_Day_7_Function | 790 | 87.11
+| 1140 |[Stone Game II](src/main/kotlin/g1101_1200/s1140_stone_game_ii/Solution.kt)| Medium | Array, Dynamic_Programming, Math, Game_Theory | 166 | 93.27
+| 1139 |[Largest 1-Bordered Square](src/main/kotlin/g1101_1200/s1139_largest_1_bordered_square/Solution.kt)| Medium | Array, Dynamic_Programming, Matrix | 224 | 100.00
+| 1138 |[Alphabet Board Path](src/main/kotlin/g1101_1200/s1138_alphabet_board_path/Solution.kt)| Medium | String, Hash_Table | 138 | 100.00
+| 1137 |[N-th Tribonacci Number](src/main/kotlin/g1101_1200/s1137_n_th_tribonacci_number/Solution.kt)| Easy | Dynamic_Programming, Math, Memoization, Dynamic_Programming_I_Day_1 | 122 | 69.35
+| 1131 |[Maximum of Absolute Value Expression](src/main/kotlin/g1101_1200/s1131_maximum_of_absolute_value_expression/Solution.kt)| Medium | Array, Math | 333 | 100.00
+| 1130 |[Minimum Cost Tree From Leaf Values](src/main/kotlin/g1101_1200/s1130_minimum_cost_tree_from_leaf_values/Solution.kt)| Medium | Dynamic_Programming, Greedy, Stack, Monotonic_Stack | 145 | 66.67
+| 1129 |[Shortest Path with Alternating Colors](src/main/kotlin/g1101_1200/s1129_shortest_path_with_alternating_colors/Solution.kt)| Medium | Breadth_First_Search, Graph, Graph_Theory_I_Day_10_Standard_Traversal | 241 | 16.67
+| 1128 |[Number of Equivalent Domino Pairs](src/main/kotlin/g1101_1200/s1128_number_of_equivalent_domino_pairs/Solution.kt)| Easy | Array, Hash_Table, Counting | 289 | 80.00
+| 1125 |[Smallest Sufficient Team](src/main/kotlin/g1101_1200/s1125_smallest_sufficient_team/Solution.kt)| Hard | Array, Dynamic_Programming, Bit_Manipulation, Bitmask | 181 | 100.00
+| 1124 |[Longest Well-Performing Interval](src/main/kotlin/g1101_1200/s1124_longest_well_performing_interval/Solution.kt)| Medium | Array, Hash_Table, Stack, Prefix_Sum, Monotonic_Stack | 313 | 100.00
+| 1123 |[Lowest Common Ancestor of Deepest Leaves](src/main/kotlin/g1101_1200/s1123_lowest_common_ancestor_of_deepest_leaves/Solution.kt)| Medium | Hash_Table, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 221 | 66.67
+| 1122 |[Relative Sort Array](src/main/kotlin/g1101_1200/s1122_relative_sort_array/Solution.kt)| Easy | Array, Hash_Table, Sorting, Counting_Sort | 183 | 90.00
+| 1117 |[Building H2O](src/main/kotlin/g1101_1200/s1117_building_h2o/H2O.kt)| Medium | Concurrency | 20 | 45.16
+| 1116 |[Print Zero Even Odd](src/main/kotlin/g1101_1200/s1116_print_zero_even_odd/ZeroEvenOdd.kt)| Medium | Concurrency | 7 | 39.21
+| 1115 |[Print FooBar Alternately](src/main/kotlin/g1101_1200/s1115_print_foobar_alternately/FooBar.kt)| Medium | Concurrency | 23 | 71.25
+| 1114 |[Print in Order](src/main/kotlin/g1101_1200/s1114_print_in_order/Foo.kt)| Easy | Concurrency | 13 | 30.13
+| 1111 |[Maximum Nesting Depth of Two Valid Parentheses Strings](src/main/kotlin/g1101_1200/s1111_maximum_nesting_depth_of_two_valid_parentheses_strings/Solution.kt)| Medium | String, Stack | 207 | 33.33
+| 1110 |[Delete Nodes And Return Forest](src/main/kotlin/g1101_1200/s1110_delete_nodes_and_return_forest/Solution.kt)| Medium | Depth_First_Search, Tree, Binary_Tree | 223 | 100.00
+| 1109 |[Corporate Flight Bookings](src/main/kotlin/g1101_1200/s1109_corporate_flight_bookings/Solution.kt)| Medium | Array, Prefix_Sum | 719 | 100.00
+| 1108 |[Defanging an IP Address](src/main/kotlin/g1101_1200/s1108_defanging_an_ip_address/Solution.kt)| Easy | String | 159 | 62.10
+| 1106 |[Parsing A Boolean Expression](src/main/kotlin/g1101_1200/s1106_parsing_a_boolean_expression/Solution.kt)| Hard | String, Stack, Recursion | 205 | 100.00
+| 1105 |[Filling Bookcase Shelves](src/main/kotlin/g1101_1200/s1105_filling_bookcase_shelves/Solution.kt)| Medium | Array, Dynamic_Programming | 175 | 33.33
+| 1104 |[Path In Zigzag Labelled Binary Tree](src/main/kotlin/g1101_1200/s1104_path_in_zigzag_labelled_binary_tree/Solution.kt)| Medium | Math, Tree, Binary_Tree | 136 | 100.00
+| 1103 |[Distribute Candies to People](src/main/kotlin/g1101_1200/s1103_distribute_candies_to_people/Solution.kt)| Easy | Math, Simulation | 129 | 100.00
 | 1073 |[Adding Two Negabinary Numbers](src/main/kotlin/g1001_1100/s1073_adding_two_negabinary_numbers/Solution.kt)| Medium | Array, Math | 187 | 100.00
 | 1072 |[Flip Columns For Maximum Number of Equal Rows](src/main/kotlin/g1001_1100/s1072_flip_columns_for_maximum_number_of_equal_rows/Solution.kt)| Medium | Array, Hash_Table, Matrix | 536 | 100.00
 | 1071 |[Greatest Common Divisor of Strings](src/main/kotlin/g1001_1100/s1071_greatest_common_divisor_of_strings/Solution.kt)| Easy | String, Math | 150 | 80.68

src/main/kotlin/g1101_1200/s1103_distribute_candies_to_people/Solution.kt

@@ -0,0 +1,28 @@
+package g1101_1200.s1103_distribute_candies_to_people
+
+// #Easy #Math #Simulation #2023_05_31_Time_129_ms_(100.00%)_Space_34.9_MB_(50.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun distributeCandies(candies: Int, numPeople: Int): IntArray {
+        var candies = candies
+        val candiesDistribution = IntArray(numPeople)
+        var count = 1
+        while (candies > 0) {
+            for (i in 0 until numPeople) {
+                if (candies >= count) {
+                    candiesDistribution[i] += count
+                    candies -= count
+                    count++
+                } else if (candies > 0) {
+                    candiesDistribution[i] += candies
+                    candies -= candies
+                }
+                if (candies == 0) {
+                    return candiesDistribution
+                }
+            }
+        }
+        return candiesDistribution
+    }
+}

src/main/kotlin/g1101_1200/s1103_distribute_candies_to_people/readme.md

@@ -0,0 +1,50 @@
+1103\. Distribute Candies to People
+
+Easy
+
+We distribute some number of `candies`, to a row of **`n = num_people`** people in the following way:
+
+We then give 1 candy to the first person, 2 candies to the second person, and so on until we give `n` candies to the last person.
+
+Then, we go back to the start of the row, giving `n + 1` candies to the first person, `n + 2` candies to the second person, and so on until we give `2 * n` candies to the last person.
+
+This process repeats (with us giving one more candy each time, and moving to the start of the row after we reach the end) until we run out of candies. The last person will receive all of our remaining candies (not necessarily one more than the previous gift).
+
+Return an array (of length `num_people` and sum `candies`) that represents the final distribution of candies.
+
+**Example 1:**
+
+**Input:** candies = 7, num\_people = 4
+
+**Output:** [1,2,3,1]
+
+**Explanation:** 
+
+On the first turn, ans[0] += 1, and the array is [1,0,0,0]. 
+
+On the second turn, ans[1] += 2, and the array is [1,2,0,0]. 
+
+On the third turn, ans[2] += 3, and the array is [1,2,3,0]. 
+
+On the fourth turn, ans[3] += 1 (because there is only one candy left), and the final array is [1,2,3,1].
+
+**Example 2:**
+
+**Input:** candies = 10, num\_people = 3
+
+**Output:** [5,2,3]
+
+**Explanation:**
+
+On the first turn, ans[0] += 1, and the array is [1,0,0]. 
+
+On the second turn, ans[1] += 2, and the array is [1,2,0]. 
+
+On the third turn, ans[2] += 3, and the array is [1,2,3]. 
+
+On the fourth turn, ans[0] += 4, and the final array is [5,2,3].
+
+**Constraints:**
+
+*   1 <= candies <= 10^9
+*   1 <= num\_people <= 1000

src/main/kotlin/g1101_1200/s1104_path_in_zigzag_labelled_binary_tree/Solution.kt

@@ -0,0 +1,24 @@
+package g1101_1200.s1104_path_in_zigzag_labelled_binary_tree
+
+// #Medium #Math #Tree #Binary_Tree #2023_05_31_Time_136_ms_(100.00%)_Space_34.1_MB_(100.00%)
+
+import java.util.LinkedList
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun pathInZigZagTree(label: Int): List<Int> {
+        var label = label
+        val answer: MutableList<Int> = LinkedList()
+        while (label != 0) {
+            answer.add(0, label)
+            val logNode = (Math.log(label.toDouble()) / Math.log(2.0)).toInt()
+            val levelStart = Math.pow(2.0, logNode.toDouble()).toInt()
+            val diff = label - levelStart
+            val d2 = diff / 2
+            val prevEnd = levelStart - 1
+            val prevLabel = prevEnd - d2
+            label = prevLabel
+        }
+        return answer
+    }
+}

src/main/kotlin/g1101_1200/s1104_path_in_zigzag_labelled_binary_tree/readme.md

@@ -0,0 +1,27 @@
+1104\. Path In Zigzag Labelled Binary Tree
+
+Medium
+
+In an infinite binary tree where every node has two children, the nodes are labelled in row order.
+
+In the odd numbered rows (ie., the first, third, fifth,...), the labelling is left to right, while in the even numbered rows (second, fourth, sixth,...), the labelling is right to left.
+
+![](https://assets.leetcode.com/uploads/2019/06/24/tree.png)
+
+Given the `label` of a node in this tree, return the labels in the path from the root of the tree to the node with that `label`.
+
+**Example 1:**
+
+**Input:** label = 14
+
+**Output:** [1,3,4,14]
+
+**Example 2:**
+
+**Input:** label = 26
+
+**Output:** [1,2,6,10,26]
+
+**Constraints:**
+
+*   `1 <= label <= 10^6`

src/main/kotlin/g1101_1200/s1105_filling_bookcase_shelves/Solution.kt

@@ -0,0 +1,24 @@
+package g1101_1200.s1105_filling_bookcase_shelves
+
+// #Medium #Array #Dynamic_Programming #2023_05_31_Time_175_ms_(33.33%)_Space_39.8_MB_(33.33%)
+
+class Solution {
+    fun minHeightShelves(books: Array<IntArray>, shelfWidth: Int): Int {
+        val n = books.size
+        val dp = IntArray(n + 1)
+        dp.fill(Int.MAX_VALUE)
+        dp[0] = 0
+        for (i in 1..n) {
+            var widthLeft = shelfWidth
+            var maxH = 0
+            for (j in i - 1 downTo 0) {
+                widthLeft -= books[j][0]
+                maxH = Math.max(maxH, books[j][1])
+                if (widthLeft >= 0) {
+                    dp[i] = Math.min(dp[i], maxH + dp[j])
+                }
+            }
+        }
+        return dp[n]
+    }
+}

src/main/kotlin/g1101_1200/s1105_filling_bookcase_shelves/readme.md

@@ -0,0 +1,41 @@
+1105\. Filling Bookcase Shelves
+
+Medium
+
+You are given an array `books` where <code>books[i] = [thickness<sub>i</sub>, height<sub>i</sub>]</code> indicates the thickness and height of the <code>i<sup>th</sup></code> book. You are also given an integer `shelfWidth`.
+
+We want to place these books in order onto bookcase shelves that have a total width `shelfWidth`.
+
+We choose some of the books to place on this shelf such that the sum of their thickness is less than or equal to `shelfWidth`, then build another level of the shelf of the bookcase so that the total height of the bookcase has increased by the maximum height of the books we just put down. We repeat this process until there are no more books to place.
+
+Note that at each step of the above process, the order of the books we place is the same order as the given sequence of books.
+
+*   For example, if we have an ordered list of `5` books, we might place the first and second book onto the first shelf, the third book on the second shelf, and the fourth and fifth book on the last shelf.
+
+Return _the minimum possible height that the total bookshelf can be after placing shelves in this manner_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/06/24/shelves.png)
+
+**Input:** books = [[1,1],[2,3],[2,3],[1,1],[1,1],[1,1],[1,2]], shelf\_width = 4
+
+**Output:** 6
+
+**Explanation:** 
+
+The sum of the heights of the 3 shelves is 1 + 3 + 2 = 6. 
+
+Notice that book number 2 does not have to be on the first shelf.
+
+**Example 2:**
+
+**Input:** books = [[1,3],[2,4],[3,2]], shelfWidth = 6
+
+**Output:** 4
+
+**Constraints:**
+
+*   `1 <= books.length <= 1000`
+*   <code>1 <= thickness<sub>i</sub> <= shelfWidth <= 1000</code>
+*   <code>1 <= height<sub>i</sub> <= 1000</code>

src/main/kotlin/g1101_1200/s1106_parsing_a_boolean_expression/Solution.kt

@@ -0,0 +1,97 @@
+package g1101_1200.s1106_parsing_a_boolean_expression
+
+// #Hard #String #Stack #Recursion #2023_05_31_Time_205_ms_(100.00%)_Space_49.5_MB_(50.00%)
+
+class Solution {
+    private var source: String? = null
+    private var index = 0
+
+    fun parseBoolExpr(expression: String?): Boolean {
+        source = expression
+        index = 0
+        return expr()
+    }
+
+    private fun expr(): Boolean {
+        val res: Boolean
+        res = if (match('!')) {
+            not()
+        } else if (match('&')) {
+            and()
+        } else if (match('|')) {
+            or()
+        } else {
+            bool()
+        }
+        return res
+    }
+
+    private operator fun not(): Boolean {
+        consume('!')
+        return !group()[0]
+    }
+
+    private fun or(): Boolean {
+        consume('|')
+        var res = false
+        for (e in group()) {
+            res = res or e
+        }
+        return res
+    }
+
+    private fun and(): Boolean {
+        consume('&')
+        var res = true
+        for (e in group()) {
+            res = res and e
+        }
+        return res
+    }
+
+    private fun group(): List<Boolean> {
+        consume('(')
+        val res: MutableList<Boolean> = ArrayList()
+        while (!match(')')) {
+            res.add(expr())
+            if (match(',')) {
+                advance()
+            }
+        }
+        consume(')')
+        return res
+    }
+
+    private fun bool(): Boolean {
+        val isTrue = match('t')
+        advance()
+        return isTrue
+    }
+
+    private val isAtEnd: Boolean
+        private get() = index >= source!!.length
+
+    private fun advance() {
+        if (isAtEnd) {
+            return
+        }
+        index++
+    }
+
+    private fun peek(): Char {
+        return source!![index]
+    }
+
+    private fun match(ch: Char): Boolean {
+        return if (isAtEnd) {
+            false
+        } else peek() == ch
+    }
+
+    private fun consume(ch: Char) {
+        if (!match(ch)) {
+            return
+        }
+        advance()
+    }
+}