Added tasks 3492-3495

Author: javadev

README.md

@@ -2088,6 +2088,10 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3495 |[Minimum Operations to Make Array Elements Zero](src/main/kotlin/g3401_3500/s3495_minimum_operations_to_make_array_elements_zero)| Hard | Array, Math, Bit_Manipulation | 12 | 100.00
+| 3494 |[Find the Minimum Amount of Time to Brew Potions](src/main/kotlin/g3401_3500/s3494_find_the_minimum_amount_of_time_to_brew_potions)| Medium | Array, Simulation, Prefix_Sum | 70 | 100.00
+| 3493 |[Properties Graph](src/main/kotlin/g3401_3500/s3493_properties_graph)| Medium | Array, Hash_Table, Depth_First_Search, Breadth_First_Search, Graph, Union_Find | 45 | 100.00
+| 3492 |[Maximum Containers on a Ship](src/main/kotlin/g3401_3500/s3492_maximum_containers_on_a_ship)| Easy | Math | 0 | 100.00
 | 3490 |[Count Beautiful Numbers](src/main/kotlin/g3401_3500/s3490_count_beautiful_numbers)| Hard | Dynamic_Programming | 246 | 100.00
 | 3489 |[Zero Array Transformation IV](src/main/kotlin/g3401_3500/s3489_zero_array_transformation_iv)| Medium | Array, Dynamic_Programming | 104 | 100.00
 | 3488 |[Closest Equal Element Queries](src/main/kotlin/g3401_3500/s3488_closest_equal_element_queries)| Medium | Array, Hash_Table, Binary_Search | 93 | 100.00
@@ -2259,7 +2263,7 @@
 | 3287 |[Find the Maximum Sequence Value of Array](src/main/kotlin/g3201_3300/s3287_find_the_maximum_sequence_value_of_array)| Hard | Array, Dynamic_Programming, Bit_Manipulation | 2893 | 33.33
 | 3286 |[Find a Safe Walk Through a Grid](src/main/kotlin/g3201_3300/s3286_find_a_safe_walk_through_a_grid)| Medium | Array, Breadth_First_Search, Matrix, Heap_Priority_Queue, Graph, Shortest_Path | 357 | 48.28
 | 3285 |[Find Indices of Stable Mountains](src/main/kotlin/g3201_3300/s3285_find_indices_of_stable_mountains)| Easy | Array | 195 | 92.68
-| 3283 |[Maximum Number of Moves to Kill All Pawns](src/main/kotlin/g3201_3300/s3283_maximum_number_of_moves_to_kill_all_pawns)| Hard | Array, Math, Breadth_First_Search, Bit_Manipulation, Bitmask, Game_Theory | 638 | 100.00
+| 3283 |[Maximum Number of Moves to Kill All Pawns](src/main/kotlin/g3201_3300/s3283_maximum_number_of_moves_to_kill_all_pawns)| Hard | Array, Math, Breadth_First_Search, Bit_Manipulation, Bitmask, Game_Theory | 147 | 100.00
 | 3282 |[Reach End of Array With Max Score](src/main/kotlin/g3201_3300/s3282_reach_end_of_array_with_max_score)| Medium | Array, Greedy | 789 | 90.91
 | 3281 |[Maximize Score of Numbers in Ranges](src/main/kotlin/g3201_3300/s3281_maximize_score_of_numbers_in_ranges)| Medium | Array, Sorting, Greedy, Binary_Search | 710 | 88.24
 | 3280 |[Convert Date to Binary](src/main/kotlin/g3201_3300/s3280_convert_date_to_binary)| Easy | String, Math | 174 | 79.31
@@ -3087,7 +3091,7 @@
 | 2217 |[Find Palindrome With Fixed Length](src/main/kotlin/g2201_2300/s2217_find_palindrome_with_fixed_length)| Medium | Array, Math | 541 | 100.00
 | 2216 |[Minimum Deletions to Make Array Beautiful](src/main/kotlin/g2201_2300/s2216_minimum_deletions_to_make_array_beautiful)| Medium | Array, Greedy, Stack | 567 | 66.67
 | 2215 |[Find the Difference of Two Arrays](src/main/kotlin/g2201_2300/s2215_find_the_difference_of_two_arrays)| Easy | Array, Hash_Table | 352 | 98.63
-| 2213 |[Longest Substring of One Repeating Character](src/main/kotlin/g2201_2300/s2213_longest_substring_of_one_repeating_character)| Hard | Array, String, Ordered_Set, Segment_Tree | 879 | 100.00
+| 2213 |[Longest Substring of One Repeating Character](src/main/kotlin/g2201_2300/s2213_longest_substring_of_one_repeating_character)| Hard | Array, String, Ordered_Set, Segment_Tree | 73 | 100.00
 | 2212 |[Maximum Points in an Archery Competition](src/main/kotlin/g2201_2300/s2212_maximum_points_in_an_archery_competition)| Medium | Array, Bit_Manipulation, Recursion, Enumeration | 210 | 100.00
 | 2211 |[Count Collisions on a Road](src/main/kotlin/g2201_2300/s2211_count_collisions_on_a_road)| Medium | String, Stack | 325 | 100.00
 | 2210 |[Count Hills and Valleys in an Array](src/main/kotlin/g2201_2300/s2210_count_hills_and_valleys_in_an_array)| Easy | Array | 153 | 80.00

src/main/kotlin/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/readme.md

@@ -39,7 +39,7 @@ You must write an algorithm with `O(log n)` runtime complexity.
 ## Solution
 
 ```kotlin
-class Solution constructor() {
+class Solution {
     fun searchRange(nums: IntArray, target: Int): IntArray {
         val ans = IntArray(2)
         ans[0] = helper(nums, target, false)

src/main/kotlin/g0001_0100/s0068_text_justification/readme.md

@@ -102,7 +102,7 @@ class Solution {
                 startWord = i + 1
                 // resetting these to 0 for processing next line
                 lineTotal = 0
-                numWordsOnLine = lineTotal
+                numWordsOnLine = 0
                 // need a new StringBuilder for the next line
                 sb = StringBuilder(maxWidth)
             }

src/main/kotlin/g0201_0300/s0289_game_of_life/readme.md

@@ -91,7 +91,7 @@ class Solution {
     }
 
     private fun compute(board: Array<IntArray>, r: Int, c: Int): Int {
-        var ret: Int = 0
+        var ret = 0
         for (arr in dim) {
             val row = arr[0] + r
             val col = arr[1] + c

src/main/kotlin/g0201_0300/s0292_nim_game/readme.md

@@ -43,10 +43,7 @@ Given `n`, the number of stones in the heap, return `true` _if you can win the g
 ```kotlin
 class Solution {
     fun canWinNim(n: Int): Boolean {
-        if (n % 4 == 0) {
-            return false
-        }
-        return true
+        return n % 4 != 0
     }
 }
 ```

src/main/kotlin/g0301_0400/s0304_range_sum_query_2d_immutable/readme.md

@@ -46,14 +46,14 @@ Implement the NumMatrix class:
 
 ```kotlin
 class NumMatrix(matrix: Array<IntArray>) {
-    private val M = matrix.size
-    private val N = if (M > 0) matrix[0].size else 0
+    private val m = matrix.size
+    private val n = if (m > 0) matrix[0].size else 0
 
-    var array = Array<IntArray> (M + 1) { IntArray(N + 1) }
+    var array = Array<IntArray> (m + 1) { IntArray(n + 1) }
 
     init {
-        for (i in 1..M) {
-            for (j in 1..N) {
+        for (i in 1..m) {
+            for (j in 1..n) {
                 array[i][j] = matrix[i - 1][j - 1] + array[i][j - 1] + array[i - 1][j] - array[i - 1][j - 1]
             }
         }

src/main/kotlin/g0301_0400/s0310_minimum_height_trees/readme.md

@@ -58,7 +58,7 @@ class Solution {
         while (queue.isNotEmpty()) {
             val size = queue.size
             val newLeaves = mutableListOf<Int>()
-            for (_sz in 0 until size) {
+            for (sz in 0 until size) {
                 val cur = queue.removeFirst()
                 newLeaves.add(cur)
                 for (next in graph[cur]) {

src/main/kotlin/g0301_0400/s0312_burst_balloons/readme.md

@@ -50,7 +50,7 @@ class Solution {
             while (ei < nums.size) {
                 val l = if (si - 1 == -1) 1 else nums[si - 1]
                 val r = if (ei + 1 == nums.size) 1 else nums[ei + 1]
-                var maxAns = -1e7.toInt()
+                var maxAns = (-1e7).toInt()
                 for (cut in si..ei) {
                     val leftAns = if (si == cut) 0 else dp[si][cut - 1]
                     val rightAns = if (ei == cut) 0 else dp[cut + 1][ei]

src/main/kotlin/g0401_0500/s0409_longest_palindrome/readme.md

@@ -41,7 +41,7 @@ class Solution {
         for (c in s.toCharArray()) {
             set.flip(c.code - 'A'.code)
         }
-        return if (set.isEmpty()) {
+        return if (set.isEmpty) {
             s.length
         } else {
             s.length - set.cardinality() + 1

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

@@ -155,7 +155,7 @@ class Solution {
     }
 
     private fun make(cur: String): Node {
-        val ans: Node = Node()
+        val ans = Node()
         val tmp: MutableList<String> = ArrayList()
         if (Character.isDigit(cur[0])) {
             ans.update(tmp, Integer.valueOf(cur))

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

@@ -45,7 +45,7 @@ class Solution {
         val fmap: MutableMap<String, Int> = HashMap()
         for (s in d) {
             var rep = 0
-            var i: Int = 0
+            var i = 0
             while (i < s.length) {
                 val c = s[i]
                 rep = if (c in '0'..'9') {

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

@@ -47,9 +47,9 @@ Given `num`, the **array-form** of an integer, and an integer `k`, return _the *
 ```kotlin
 @Suppress("NAME_SHADOWING")
 class Solution {
-    fun addToArrayForm(num: IntArray, k: Int): List<Int?> {
+    fun addToArrayForm(num: IntArray, k: Int): List<Int> {
         var k = k
-        val result = ArrayList<Int?>()
+        val result = ArrayList<Int>()
         var carry = 0
         for (i in num.indices.reversed()) {
             val temp = num[i] + k % 10 + carry

src/main/kotlin/g1001_1100/s1048_longest_string_chain/readme.md

@@ -50,7 +50,7 @@ Return _the **length** of the **longest possible word chain** with words chosen
 ```kotlin
 class Solution {
     fun longestStrChain(words: Array<String>): Int {
-        val lenStr = arrayOfNulls<MutableList<String>?>(20)
+        val lenStr = arrayOfNulls<MutableList<String>>(20)
         for (word in words) {
             val len = word.length
             if (lenStr[len] == null) {

src/main/kotlin/g1601_1700/s1639_number_of_ways_to_form_a_target_string_given_a_dictionary/readme.md

@@ -68,7 +68,7 @@ Return _the number of ways to form `target` from `words`_. Since the answer may
 class Solution {
     fun numWays(words: Array<String>, target: String): Int {
         val counts = precompute(words)
-        val memo = Array(target.length) { arrayOfNulls<Int?>(words[0].length) }
+        val memo = Array(target.length) { arrayOfNulls<Int>(words[0].length) }
         return solve(memo, counts, words, target, 0, 0)
     }
 

src/main/kotlin/g1701_1800/s1739_building_boxes/readme.md

@@ -87,7 +87,7 @@ class Solution {
     }
 
     private fun product(vararg vals: Long): Long {
-        var product: Long = 1L
+        var product = 1L
         for (`val`: Long in vals) {
             product *= `val`
         }

src/main/kotlin/g1701_1800/s1748_sum_of_unique_elements/readme.md

@@ -44,7 +44,7 @@ Return _the **sum** of all the unique elements of_ `nums`.
 class Solution {
     fun sumOfUnique(nums: IntArray): Int {
         val map: MutableMap<Int, Int> = HashMap()
-        var sum: Int = 0
+        var sum = 0
         for (num: Int in nums) {
             map.put(num, map.getOrDefault(num, 0) + 1)
         }

src/main/kotlin/g1701_1800/s1749_maximum_absolute_sum_of_any_subarray/readme.md

@@ -40,9 +40,9 @@ Note that `abs(x)` is defined as follows:
 ```kotlin
 class Solution {
     fun maxAbsoluteSum(nums: IntArray): Int {
-        var min: Int = 0
-        var max: Int = 0
-        var s: Int = 0
+        var min = 0
+        var max = 0
+        var s = 0
         for (num: Int in nums) {
             s += num
             min = Math.min(min, s)

src/main/kotlin/g2001_2100/s2019_the_score_of_students_solving_math_expression/readme.md

@@ -81,7 +81,7 @@ class Solution {
         val st = ArrayDeque<Int>()
         val n = s.length
         var i = 0
-        dp = Array(n) { arrayOfNulls<HashSet<Int>?>(n) }
+        dp = Array(n) { arrayOfNulls<HashSet<Int>>(n) }
         while (i < n) {
             if (s[i].code - '0'.code >= 0 && s[i].code - '9'.code <= 0) {
                 st.push(s[i].code - '0'.code)

src/main/kotlin/g2201_2300/s2213_longest_substring_of_one_repeating_character/readme.md

@@ -50,86 +50,68 @@ Thus, we return [2,3].
 
 ```kotlin
 class Solution {
-    internal class TreeNode(var start: Int, var end: Int) {
-        var leftChar = 0.toChar()
-        var leftCharLen = 0
-        var rightChar = 0.toChar()
-        var rightCharLen = 0
-        var max = 0
-        var left: TreeNode? = null
-        var right: TreeNode? = null
-    }
+    private lateinit var ca: CharArray
 
     fun longestRepeating(s: String, queryCharacters: String, queryIndices: IntArray): IntArray {
-        val sChar = s.toCharArray()
-        val qChar = queryCharacters.toCharArray()
-        val root = buildTree(sChar, 0, sChar.size - 1)
-        val result = IntArray(qChar.size)
-        for (i in qChar.indices) {
-            updateTree(root, queryIndices[i], qChar[i])
-            if (root != null) {
-                result[i] = root.max
-            }
+        ca = s.toCharArray()
+        val result = IntArray(queryIndices.size)
+        val root = SegmentTree(0, ca.size)
+        for (i in queryIndices.indices) {
+            ca[queryIndices[i]] = queryCharacters[i]
+            root.update(queryIndices[i])
+            result[i] = root.longest
         }
         return result
     }
 
-    private fun buildTree(s: CharArray, from: Int, to: Int): TreeNode? {
-        if (from > to) {
-            return null
-        }
-        val root = TreeNode(from, to)
-        if (from == to) {
-            root.max = 1
-            root.leftChar = s[from]
-            root.rightChar = root.leftChar
-            root.rightCharLen = 1
-            root.leftCharLen = root.rightCharLen
-            return root
+    private inner class SegmentTree(val start: Int, val end: Int) {
+        var longest: Int = 0
+        var leftLength: Int = 0
+        var rightLength: Int = 0
+        private lateinit var left: SegmentTree
+        private lateinit var right: SegmentTree
+
+        init {
+            if (end - start > 1) {
+                val mid = (start + end) / 2
+                left = SegmentTree(start, mid)
+                right = SegmentTree(mid, end)
+                merge()
+            } else {
+                longest = 1
+                leftLength = 1
+                rightLength = 1
+            }
         }
-        val middle = from + (to - from) / 2
-        root.left = buildTree(s, from, middle)
-        root.right = buildTree(s, middle + 1, to)
-        updateNode(root)
-        return root
-    }
 
-    private fun updateTree(root: TreeNode?, index: Int, c: Char) {
-        if (root == null || root.start > index || root.end < index) {
-            return
-        }
-        if (root.start == index && root.end == index) {
-            root.rightChar = c
-            root.leftChar = root.rightChar
-            return
+        fun update(index: Int) {
+            if (end - start == 1) return
+            if (index < (left.end)) {
+                left.update(index)
+            } else {
+                right.update(index)
+            }
+            merge()
         }
-        updateTree(root.left, index, c)
-        updateTree(root.right, index, c)
-        updateNode(root)
-    }
 
-    private fun updateNode(root: TreeNode?) {
-        if (root == null) {
-            return
-        }
-        root.leftChar = root.left!!.leftChar
-        root.leftCharLen = root.left!!.leftCharLen
-        root.rightChar = root.right!!.rightChar
-        root.rightCharLen = root.right!!.rightCharLen
-        root.max = Math.max(root.left!!.max, root.right!!.max)
-        if (root.left!!.rightChar == root.right!!.leftChar) {
-            val len = root.left!!.rightCharLen + root.right!!.leftCharLen
-            if (root.left!!.leftChar == root.left!!.rightChar &&
-                root.left!!.leftCharLen == root.left!!.end - root.left!!.start + 1
-            ) {
-                root.leftCharLen = len
-            }
-            if (root.right!!.leftChar == root.right!!.rightChar &&
-                root.right!!.leftCharLen == root.right!!.end - root.right!!.start + 1
-            ) {
-                root.rightCharLen = len
+        private fun merge() {
+            longest = maxOf(left.longest, right.longest)
+            if (ca[left.end - 1] == ca[right.start]) {
+                longest = maxOf(longest, left.rightLength + right.leftLength)
+                leftLength = if (left.leftLength == left.end - left.start) {
+                    left.leftLength + right.leftLength
+                } else {
+                    left.leftLength
+                }
+                rightLength = if (right.rightLength == (right.end - right.start)) {
+                    right.rightLength + left.rightLength
+                } else {
+                    right.rightLength
+                }
+            } else {
+                leftLength = left.leftLength
+                rightLength = right.rightLength
             }
-            root.max = Math.max(root.max, len)
         }
     }
 }