Added tasks 1154, 1155, 1156, 1157, 1158, 1160, 1161, 1162, 1163, 1169, 1170, 1171, 1172, 1175, 1177, 1178, 1179, 1184, 1185, 1186, 1187, 1189, 1190, 1191, 1192, 1195, 1200

Author: javadev

README.md

@@ -1614,6 +1614,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 1162 |[As Far from Land as Possible](src/main/kotlin/g1101_1200/s1162_as_far_from_land_as_possible/Solution.kt)| Medium | Array, Dynamic_Programming, Breadth_First_Search, Matrix | 362 | 81.25
 | 0417 |[Pacific Atlantic Water Flow](src.save/main/kotlin/g0401_0500/s0417_pacific_atlantic_water_flow/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix | 319 | 100.00
 
 #### Day 5 Matrix Related Problems
@@ -1738,6 +1739,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 1158 |[Market Analysis I](src/main/kotlin/g1101_1200/s1158_market_analysis_i/script.sql)| Medium | Database | 2470 | 44.76
 
 #### Day 10 Where
 
@@ -1749,6 +1751,33 @@ 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 ||  | 
+| 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
+| 1189 |[Maximum Number of Balloons](src/main/kotlin/g1101_1200/s1189_maximum_number_of_balloons/Solution.kt)| Easy | String, Hash_Table, Counting | 136 | 98.31
+| 1187 |[Make Array Strictly Increasing](src/main/kotlin/g1101_1200/s1187_make_array_strictly_increasing/Solution.kt)| Hard | Array, Dynamic_Programming, Binary_Search | 308 | 100.00
+| 1186 |[Maximum Subarray Sum with One Deletion](src/main/kotlin/g1101_1200/s1186_maximum_subarray_sum_with_one_deletion/Solution.kt)| Medium | Array, Dynamic_Programming | 304 | 50.00
+| 1185 |[Day of the Week](src/main/kotlin/g1101_1200/s1185_day_of_the_week/Solution.kt)| Easy | Math | 127 | 50.00
+| 1184 |[Distance Between Bus Stops](src/main/kotlin/g1101_1200/s1184_distance_between_bus_stops/Solution.kt)| Easy | Array | 164 | 57.14
+| 1179 |[Reformat Department Table](src/main/kotlin/g1101_1200/s1179_reformat_department_table/script.sql)| Easy | Database | 815 | 90.95
+| 1178 |[Number of Valid Words for Each Puzzle](src/main/kotlin/g1101_1200/s1178_number_of_valid_words_for_each_puzzle/Solution.kt)| Hard | Array, String, Hash_Table, Bit_Manipulation, Trie | 675 | 100.00
+| 1177 |[Can Make Palindrome from Substring](src/main/kotlin/g1101_1200/s1177_can_make_palindrome_from_substring/Solution.kt)| Medium | String, Hash_Table, Bit_Manipulation, Prefix_Sum | 937 | 100.00
+| 1175 |[Prime Arrangements](src/main/kotlin/g1101_1200/s1175_prime_arrangements/Solution.kt)| Easy | Math | 129 | 50.00
+| 1172 |[Dinner Plate Stacks](src/main/kotlin/g1101_1200/s1172_dinner_plate_stacks/DinnerPlates.kt)| Hard | Hash_Table, Stack, Design, Heap_Priority_Queue | 1160 | 50.00
+| 1171 |[Remove Zero Sum Consecutive Nodes from Linked List](src/main/kotlin/g1101_1200/s1171_remove_zero_sum_consecutive_nodes_from_linked_list/Solution.kt)| Medium | Hash_Table, Linked_List | 194 | 50.00
+| 1170 |[Compare Strings by Frequency of the Smallest Character](src/main/kotlin/g1101_1200/s1170_compare_strings_by_frequency_of_the_smallest_character/Solution.kt)| Medium | Array, String, Hash_Table, Sorting, Binary_Search | 221 | 50.00
+| 1169 |[Invalid Transactions](src/main/kotlin/g1101_1200/s1169_invalid_transactions/Solution.kt)| Medium | Array, String, Hash_Table, Sorting | 362 | 57.14
+| 1163 |[Last Substring in Lexicographical Order](src/main/kotlin/g1101_1200/s1163_last_substring_in_lexicographical_order/Solution.kt)| Hard | String, Two_Pointers | 254 | 100.00
+| 1162 |[As Far from Land as Possible](src/main/kotlin/g1101_1200/s1162_as_far_from_land_as_possible/Solution.kt)| Medium | Array, Dynamic_Programming, Breadth_First_Search, Matrix, Graph_Theory_I_Day_4_Matrix_Related_Problems | 362 | 81.25
+| 1161 |[Maximum Level Sum of a Binary Tree](src/main/kotlin/g1101_1200/s1161_maximum_level_sum_of_a_binary_tree/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 445 | 87.50
+| 1160 |[Find Words That Can Be Formed by Characters](src/main/kotlin/g1101_1200/s1160_find_words_that_can_be_formed_by_characters/Solution.kt)| Easy | Array, String, Hash_Table | 288 | 72.22
+| 1158 |[Market Analysis I](src/main/kotlin/g1101_1200/s1158_market_analysis_i/script.sql)| Medium | Database, SQL_I_Day_9_Control_of_Flow | 2470 | 44.76
+| 1157 |[Online Majority Element In Subarray](src/main/kotlin/g1101_1200/s1157_online_majority_element_in_subarray/MajorityChecker.kt)| Hard | Array, Binary_Search, Design, Segment_Tree, Binary_Indexed_Tree | 953 | 100.00
+| 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
 | 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
 | 1036 |[Escape a Large Maze](src/main/kotlin/g1001_1100/s1036_escape_a_large_maze/Solution.kt)| Hard | Array, Hash_Table, Depth_First_Search, Breadth_First_Search | 387 | 100.00
 | 1035 |[Uncrossed Lines](src/main/kotlin/g1001_1100/s1035_uncrossed_lines/Solution.kt)| Medium | Array, Dynamic_Programming | 162 | 93.33

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

@@ -0,0 +1,23 @@
+package g1101_1200.s1154_day_of_the_year
+
+// #Easy #String #Math #2023_05_25_Time_317_ms_(70.00%)_Space_59.3_MB_(20.00%)
+
+class Solution {
+    fun dayOfYear(date: String): Int {
+        val monthDays = intArrayOf(0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
+        val dateArr = date.split("-".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+        val year = dateArr[0].toInt()
+        val month = dateArr[1].toInt()
+        val day = dateArr[2].toInt()
+        var dayCount = 0
+        val leapYear = year % 4 == 0 && year % 100 != 0 || year % 400 == 0
+        for (i in 1 until month) {
+            dayCount += monthDays[i]
+        }
+        dayCount += day
+        if (leapYear && month > 2) {
+            dayCount++
+        }
+        return dayCount
+    }
+}

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

@@ -0,0 +1,25 @@
+1154\. Day of the Year
+
+Easy
+
+Given a string `date` representing a [Gregorian calendar](https://en.wikipedia.org/wiki/Gregorian_calendar) date formatted as `YYYY-MM-DD`, return _the day number of the year_.
+
+**Example 1:**
+
+**Input:** date = "2019-01-09"
+
+**Output:** 9
+
+**Explanation:** Given date is the 9th day of the year in 2019.
+
+**Example 2:**
+
+**Input:** date = "2019-02-10"
+
+**Output:** 41
+
+**Constraints:**
+
+*   `date.length == 10`
+*   `date[4] == date[7] == '-'`, and all other `date[i]`'s are digits
+*   `date` represents a calendar date between Jan 1<sup>st</sup>, 1900 and Dec 31<sup>th</sup>, 2019.

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

@@ -0,0 +1,35 @@
+package g1101_1200.s1155_number_of_dice_rolls_with_target_sum
+
+// #Medium #Dynamic_Programming #2023_05_25_Time_158_ms_(80.95%)_Space_37.7_MB_(23.81%)
+
+class Solution {
+    private var memo: Array<IntArray> = arrayOf()
+
+    private var k = 0
+    private fun dp(diceLeft: Int, targetLeft: Int): Int {
+        if (diceLeft == 0) {
+            return if (targetLeft == 0) {
+                1
+            } else 0
+        }
+        if (memo[diceLeft][targetLeft] == -1) {
+            var res = 0
+            for (i in 1..Math.min(k, targetLeft)) {
+                res += dp(diceLeft - 1, targetLeft - i)
+                val modulo = 1000000007
+                res %= modulo
+            }
+            memo[diceLeft][targetLeft] = res
+        }
+        return memo[diceLeft][targetLeft]
+    }
+
+    fun numRollsToTarget(n: Int, k: Int, target: Int): Int {
+        this.k = k
+        memo = Array(n + 1) { IntArray(target + 1) }
+        for (i in memo) {
+            i.fill(-1)
+        }
+        return dp(n, target)
+    }
+}

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

@@ -0,0 +1,40 @@
+1155\. Number of Dice Rolls With Target Sum
+
+Medium
+
+You have `n` dice and each die has `k` faces numbered from `1` to `k`.
+
+Given three integers `n`, `k`, and `target`, return _the number of possible ways (out of the_ <code>k<sup>n</sup></code> _total ways)_ _to roll the dice so the sum of the face-up numbers equals_ `target`. Since the answer may be too large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** n = 1, k = 6, target = 3
+
+**Output:** 1
+
+**Explanation:** You throw one die with 6 faces. 
+
+There is only one way to get a sum of 3.
+
+**Example 2:**
+
+**Input:** n = 2, k = 6, target = 7
+
+**Output:** 6
+
+**Explanation:** You throw two dice, each with 6 faces. 
+
+There are 6 ways to get a sum of 7: 1+6, 2+5, 3+4, 4+3, 5+2, 6+1.
+
+**Example 3:**
+
+**Input:** n = 30, k = 30, target = 500
+
+**Output:** 222616187
+
+**Explanation:** The answer must be returned modulo 10<sup>9</sup> + 7.
+
+**Constraints:**
+
+*   `1 <= n, k <= 30`
+*   `1 <= target <= 1000`

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

@@ -0,0 +1,52 @@
+package g1101_1200.s1156_swap_for_longest_repeated_character_substring
+
+// #Medium #String #Sliding_Window #2023_05_25_Time_195_ms_(20.00%)_Space_38.9_MB_(20.00%)
+
+class Solution {
+    private class Pair(var character: Char, var count: Int)
+
+    fun maxRepOpt1(text: String): Int {
+        val pairs: MutableList<Pair> = ArrayList()
+        val map: MutableMap<Char, Int> = HashMap()
+        // collect counts for each char-block
+        var i = 0
+        while (i < text.length) {
+            val c = text[i]
+            var count = 0
+            while (i < text.length && text[i] == c) {
+                count++
+                i++
+            }
+            pairs.add(Pair(c, count))
+            map[c] = map.getOrDefault(c, 0) + count
+        }
+        var max = 0
+        // case 1, swap 1 item to the boundary of a consecutive cha-block to achieve possible max
+        // length
+        // we need total count to make sure whether a swap is possible!
+        for (p in pairs) {
+            val totalCount = map.getValue(p.character)
+            max = if (totalCount > p.count) {
+                Math.max(max, p.count + 1)
+            } else {
+                Math.max(max, p.count)
+            }
+        }
+        // case 2, find xxxxYxxxxx pattern
+        // we need total count to make sure whether a swap is possible!
+        for (j in 1 until pairs.size - 1) {
+            if (pairs[j - 1].character == pairs[j + 1].character &&
+                pairs[j].count == 1
+            ) {
+                val totalCount = map.getValue(pairs[j - 1].character)
+                val groupSum = pairs[j - 1].count + pairs[j + 1].count
+                max = if (totalCount > groupSum) {
+                    Math.max(max, groupSum + 1)
+                } else {
+                    Math.max(max, groupSum)
+                }
+            }
+        }
+        return max
+    }
+}

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

@@ -0,0 +1,36 @@
+1156\. Swap For Longest Repeated Character Substring
+
+Medium
+
+You are given a string `text`. You can swap two of the characters in the `text`.
+
+Return _the length of the longest substring with repeated characters_.
+
+**Example 1:**
+
+**Input:** text = "ababa"
+
+**Output:** 3
+
+**Explanation:** We can swap the first 'b' with the last 'a', or the last 'b' with the first 'a'. Then, the longest repeated character substring is "aaa" with length 3.
+
+**Example 2:**
+
+**Input:** text = "aaabaaa"
+
+**Output:** 6
+
+**Explanation:** Swap 'b' with the last 'a' (or the first 'a'), and we get longest repeated character substring "aaaaaa" with length 6.
+
+**Example 3:**
+
+**Input:** text = "aaaaa"
+
+**Output:** 5
+
+**Explanation:** No need to swap, longest repeated character substring is "aaaaa" with length is 5.
+
+**Constraints:**
+
+*   <code>1 <= text.length <= 2 * 10<sup>4</sup></code>
+*   `text` consist of lowercase English characters only.

src/main/kotlin/g1101_1200/s1157_online_majority_element_in_subarray/MajorityChecker.kt

@@ -0,0 +1,52 @@
+package g1101_1200.s1157_online_majority_element_in_subarray
+
+// #Hard #Array #Binary_Search #Design #Segment_Tree #Binary_Indexed_Tree
+// #2023_05_25_Time_953_ms_(100.00%)_Space_139_MB_(100.00%)
+
+class MajorityChecker(arr: IntArray) {
+    private val valToInd: MutableMap<Int, MutableList<Int>>
+    private val bitCount: Array<IntArray>
+
+    init {
+        valToInd = HashMap()
+        bitCount = Array(arr.size + 1) { IntArray(NUM_OF_BITS) }
+        for (i in arr.indices) {
+            var `val` = arr[i]
+            val indList = valToInd.computeIfAbsent(`val`) { _: Int? -> ArrayList() }
+            indList.add(i)
+            for (j in 0 until NUM_OF_BITS) {
+                bitCount[i + 1][j] = bitCount[i][j] + (`val` and 1)
+                `val` = `val` shr 1
+            }
+        }
+    }
+
+    fun query(left: Int, right: Int, threshold: Int): Int {
+        var candidateVal = 0
+        for (i in NUM_OF_BITS - 1 downTo 0) {
+            val curBit = if (bitCount[right + 1][i] - bitCount[left][i] >= threshold) 1 else 0
+            candidateVal = (candidateVal shl 1) + curBit
+        }
+        val indList: List<Int>? = valToInd[candidateVal]
+        if (indList == null || indList.size < threshold) {
+            return -1
+        }
+        var indOfLeft = indList.binarySearch(left)
+        if (indOfLeft < 0) {
+            indOfLeft = -indOfLeft - 1
+        }
+        var indOfRight = indList.binarySearch(right)
+        if (indOfRight < 0) {
+            indOfRight = -indOfRight - 2
+        }
+        return if (indOfRight - indOfLeft + 1 >= threshold) {
+            candidateVal
+        } else {
+            -1
+        }
+    }
+
+    companion object {
+        private const val NUM_OF_BITS = 15
+    }
+}

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

@@ -0,0 +1,34 @@
+1157\. Online Majority Element In Subarray
+
+Hard
+
+Design a data structure that efficiently finds the **majority element** of a given subarray.
+
+The **majority element** of a subarray is an element that occurs `threshold` times or more in the subarray.
+
+Implementing the `MajorityChecker` class:
+
+*   `MajorityChecker(int[] arr)` Initializes the instance of the class with the given array `arr`.
+*   `int query(int left, int right, int threshold)` returns the element in the subarray `arr[left...right]` that occurs at least `threshold` times, or `-1` if no such element exists.
+
+**Example 1:**
+
+**Input** ["MajorityChecker", "query", "query", "query"] [[[1, 1, 2, 2, 1, 1]], [0, 5, 4], [0, 3, 3], [2, 3, 2]]
+
+**Output:** [null, 1, -1, 2]
+
+**Explanation:** 
+
+MajorityChecker majorityChecker = new MajorityChecker([1, 1, 2, 2, 1, 1]); 
+majorityChecker.query(0, 5, 4); // return 1 
+majorityChecker.query(0, 3, 3); // return -1 
+majorityChecker.query(2, 3, 2); // return 2
+
+**Constraints:**
+
+*   <code>1 <= arr.length <= 2 * 10<sup>4</sup></code>
+*   <code>1 <= arr[i] <= 2 * 10<sup>4</sup></code>
+*   `0 <= left <= right < arr.length`
+*   `threshold <= right - left + 1`
+*   `2 * threshold > right - left + 1`
+*   At most <code>10<sup>4</sup></code> calls will be made to `query`.