Added tasks 3536-3539

Author: javadev

README.md

@@ -2088,6 +2088,10 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3539 |[Find Sum of Array Product of Magical Sequences](src/main/kotlin/g3501_3600/s3539_find_sum_of_array_product_of_magical_sequences)| Hard | Array, Dynamic_Programming, Math, Bit_Manipulation, Bitmask, Combinatorics | 60 | 100.00
+| 3538 |[Merge Operations for Minimum Travel Time](src/main/kotlin/g3501_3600/s3538_merge_operations_for_minimum_travel_time)| Hard | Array, Dynamic_Programming, Prefix_Sum | 10 | 100.00
+| 3537 |[Fill a Special Grid](src/main/kotlin/g3501_3600/s3537_fill_a_special_grid)| Medium | Array, Matrix, Divide_and_Conquer | 2 | 100.00
+| 3536 |[Maximum Product of Two Digits](src/main/kotlin/g3501_3600/s3536_maximum_product_of_two_digits)| Easy | Math, Sorting | 1 | 100.00
 | 3534 |[Path Existence Queries in a Graph II](src/main/kotlin/g3501_3600/s3534_path_existence_queries_in_a_graph_ii)| Hard | Array, Sorting, Greedy, Binary_Search, Graph | 152 | 100.00
 | 3533 |[Concatenated Divisibility](src/main/kotlin/g3501_3600/s3533_concatenated_divisibility)| Hard | Array, Dynamic_Programming, Bit_Manipulation, Bitmask | 20 | 100.00
 | 3532 |[Path Existence Queries in a Graph I](src/main/kotlin/g3501_3600/s3532_path_existence_queries_in_a_graph_i)| Medium | Array, Binary_Search, Graph, Union_Find | 5 | 90.91
@@ -2141,7 +2145,7 @@
 | 3477 |[Fruits Into Baskets II](src/main/kotlin/g3401_3500/s3477_fruits_into_baskets_ii)| Easy | Array, Binary_Search, Simulation, Segment_Tree | 3 | 100.00
 | 3475 |[DNA Pattern Recognition](src/main/kotlin/g3401_3500/s3475_dna_pattern_recognition)| Medium | Database | 362 | 83.49
 | 3474 |[Lexicographically Smallest Generated String](src/main/kotlin/g3401_3500/s3474_lexicographically_smallest_generated_string)| Hard | String, Greedy, String_Matching | 30 | 100.00
-| 3473 |[Sum of K Subarrays With Length at Least M](src/main/kotlin/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m)| Medium | Array, Dynamic_Programming, Prefix_Sum | 227 | 24.47
+| 3473 |[Sum of K Subarrays With Length at Least M](src/main/kotlin/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m)| Medium | Array, Dynamic_Programming, Prefix_Sum | 33 | 98.18
 | 3472 |[Longest Palindromic Subsequence After at Most K Operations](src/main/kotlin/g3401_3500/s3472_longest_palindromic_subsequence_after_at_most_k_operations)| Medium | String, Dynamic_Programming | 142 | 55.00
 | 3471 |[Find the Largest Almost Missing Integer](src/main/kotlin/g3401_3500/s3471_find_the_largest_almost_missing_integer)| Easy | Array, Hash_Table | 6 | 86.49
 | 3470 |[Permutations IV](src/main/kotlin/g3401_3500/s3470_permutations_iv)| Hard | Array, Math, Enumeration, Combinatorics | 4 | 96.77
@@ -3006,7 +3010,7 @@
 | 2369 |[Check if There is a Valid Partition For The Array](src/main/kotlin/g2301_2400/s2369_check_if_there_is_a_valid_partition_for_the_array)| Medium | Array, Dynamic_Programming | 533 | 100.00
 | 2368 |[Reachable Nodes With Restrictions](src/main/kotlin/g2301_2400/s2368_reachable_nodes_with_restrictions)| Medium | Array, Hash_Table, Depth_First_Search, Breadth_First_Search, Tree, Graph | 1199 | 76.92
 | 2367 |[Number of Arithmetic Triplets](src/main/kotlin/g2301_2400/s2367_number_of_arithmetic_triplets)| Easy | Array, Hash_Table, Two_Pointers, Enumeration | 146 | 91.18
-| 2366 |[Minimum Replacements to Sort the Array](src/main/kotlin/g2301_2400/s2366_minimum_replacements_to_sort_the_array)| Hard | Array, Math, Greedy | 433 | 100.00
+| 2366 |[Minimum Replacements to Sort the Array](src/main/kotlin/g2301_2400/s2366_minimum_replacements_to_sort_the_array)| Hard | Array, Math, Greedy | 4 | 100.00
 | 2365 |[Task Scheduler II](src/main/kotlin/g2301_2400/s2365_task_scheduler_ii)| Medium | Array, Hash_Table, Simulation | 595 | 100.00
 | 2364 |[Count Number of Bad Pairs](src/main/kotlin/g2301_2400/s2364_count_number_of_bad_pairs)| Medium | Array, Hash_Table | 590 | 100.00
 | 2363 |[Merge Similar Items](src/main/kotlin/g2301_2400/s2363_merge_similar_items)| Easy | Array, Hash_Table, Sorting, Ordered_Set | 320 | 100.00
@@ -4041,7 +4045,7 @@
 | 1025 |[Divisor Game](src/main/kotlin/g1001_1100/s1025_divisor_game)| Easy | Dynamic_Programming, Math, Game_Theory, Brainteaser | 114 | 93.33
 | 1024 |[Video Stitching](src/main/kotlin/g1001_1100/s1024_video_stitching)| Medium | Array, Dynamic_Programming, Greedy | 141 | 100.00
 | 1023 |[Camelcase Matching](src/main/kotlin/g1001_1100/s1023_camelcase_matching)| Medium | String, Two_Pointers, Trie, String_Matching | 149 | 60.00
-| 1022 |[Sum of Root To Leaf Binary Numbers](src/main/kotlin/g1001_1100/s1022_sum_of_root_to_leaf_binary_numbers)| Easy | Depth_First_Search, Tree, Binary_Tree | 158 | 88.89
+| 1022 |[Sum of Root To Leaf Binary Numbers](src/main/kotlin/g1001_1100/s1022_sum_of_root_to_leaf_binary_numbers)| Easy | Depth_First_Search, Tree, Binary_Tree | 0 | 100.00
 | 1021 |[Remove Outermost Parentheses](src/main/kotlin/g1001_1100/s1021_remove_outermost_parentheses)| Easy | String, Stack | 156 | 60.00
 | 1020 |[Number of Enclaves](src/main/kotlin/g1001_1100/s1020_number_of_enclaves)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find, Graph_Theory_I_Day_3_Matrix_Related_Problems | 283 | 90.70
 | 1019 |[Next Greater Node In Linked List](src/main/kotlin/g1001_1100/s1019_next_greater_node_in_linked_list)| Medium | Array, Stack, Linked_List, Monotonic_Stack | 472 | 75.00
@@ -4722,7 +4726,7 @@
 | 0197 |[Rising Temperature](src/main/kotlin/g0101_0200/s0197_rising_temperature)| Easy | Database, SQL_I_Day_6_Union | 394 | 94.15
 | 0196 |[Delete Duplicate Emails](src/main/kotlin/g0101_0200/s0196_delete_duplicate_emails)| Easy | Database, SQL_I_Day_2_Select_and_Order | 593 | 94.17
 | 0195 |[Tenth Line](src/main/kotlin/g0101_0200/s0195_tenth_line)| Easy | Shell | 36 | 87.50
-| 0194 |[Transpose File](src/main/kotlin/g0101_0200/s0194_transpose_file)| Medium | Shell | 461 | 33.47
+| 0194 |[Transpose File](src/main/kotlin/g0101_0200/s0194_transpose_file)| Medium | Shell | 61 | 88.19
 | 0193 |[Valid Phone Numbers](src/main/kotlin/g0101_0200/s0193_valid_phone_numbers)| Easy | Shell | 98 | 88.64
 | 0192 |[Word Frequency](src/main/kotlin/g0101_0200/s0192_word_frequency)| Medium | Shell | 96 | 80.40
 | 0191 |[Number of 1 Bits](src/main/kotlin/g0101_0200/s0191_number_of_1_bits)| Easy | Top_Interview_Questions, Bit_Manipulation, Algorithm_I_Day_13_Bit_Manipulation, Programming_Skills_I_Day_2_Operator, Udemy_Bit_Manipulation, Top_Interview_150_Bit_Manipulation | 237 | 68.44

src/main/kotlin/g0101_0200/s0194_transpose_file/readme.md

@@ -26,10 +26,19 @@ Output the following:
 
 ```bash
 # Read from the file file.txt and print its transposed content to stdout.
-wordcount=$(head -1 file.txt | wc -w)
-col_n=1
-while [[ $col_n -le $wordcount ]]; do
-	awk "{ print \$$col_n }" file.txt | paste -sd " "
-	col_n=$((col_n + 1))
-done
+awk '
+{
+    for (i = 1; i <= NF; i++) {
+        if (NR == 1) {
+            a[i] = $i
+        } else {
+            a[i] = a[i] " " $i
+        }
+    }
+}
+END {
+    for (i = 1; i <= NF; i++) {
+        print a[i]
+    }
+}' file.txt
 ```

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

@@ -51,32 +51,19 @@ import com_github_leetcode.TreeNode
  */
 class Solution {
     fun sumRootToLeaf(root: TreeNode?): Int {
-        val paths: MutableList<List<Int>> = ArrayList()
-        dfs(root, paths, ArrayList())
-        var sum = 0
-        for (list in paths) {
-            var num = 0
-            for (i in list) {
-                num = (num shl 1) + i
-            }
-            sum += num
-        }
-        return sum
+        return sumRootToLeaf(root, 0)
     }
 
-    private fun dfs(root: TreeNode?, paths: MutableList<List<Int>>, path: MutableList<Int>) {
-        path.add(root!!.`val`)
-        if (root.left != null) {
-            dfs(root.left!!, paths, path)
-            path.removeAt(path.size - 1)
-        }
-        if (root.right != null) {
-            dfs(root.right!!, paths, path)
-            path.removeAt(path.size - 1)
+    private fun sumRootToLeaf(root: TreeNode?, sum: Int): Int {
+        var sum = sum
+        if (root == null) {
+            return 0
         }
+        sum = 2 * sum + root.`val`
         if (root.left == null && root.right == null) {
-            paths.add(ArrayList(path))
+            return sum
         }
+        return sumRootToLeaf(root.left, sum) + sumRootToLeaf(root.right, sum)
     }
 }
 ```

src/main/kotlin/g2301_2400/s2366_minimum_replacements_to_sort_the_array/readme.md

@@ -43,15 +43,16 @@ There are 2 steps to sort the array in non-decreasing order. Therefore, we retur
 ```kotlin
 class Solution {
     fun minimumReplacement(nums: IntArray): Long {
-        var limit = nums[nums.size - 1]
+        val n = nums.size
+        var prev = nums[n - 1]
         var ans: Long = 0
-        for (i in nums.size - 2 downTo 0) {
-            var replacements = nums[i] / limit - 1
-            if (nums[i] % limit != 0) {
-                replacements++
+        for (i in n - 2 downTo 0) {
+            var noOfTime = nums[i] / prev
+            if (nums[i] % prev != 0) {
+                noOfTime++
+                prev = nums[i] / noOfTime
             }
-            ans += replacements.toLong()
-            limit = nums[i] / (replacements + 1)
+            ans += (noOfTime - 1).toLong()
         }
         return ans
     }

src/main/kotlin/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m/readme.md

@@ -44,44 +44,25 @@ The optimal choice is choosing each element as a subarray. The output is `(-10)
 ## Solution
 
 ```kotlin
-import kotlin.math.max
-
 class Solution {
     fun maxSum(nums: IntArray, k: Int, m: Int): Int {
         val n = nums.size
-        // Calculate prefix sums
-        val prefixSum = IntArray(n + 1)
-        for (i in 0..<n) {
-            prefixSum[i + 1] = prefixSum[i] + nums[i]
+        val dp = Array(k + 1) { IntArray(n + 1) { Int.MIN_VALUE } }
+        val ps = IntArray(n + 1)
+        for (i in nums.indices) {
+            ps[i + 1] = ps[i] + nums[i]
         }
-        // using elements from nums[0...i-1]
-        val dp = Array<IntArray>(n + 1) { IntArray(k + 1) }
-        // Initialize dp array
-        for (j in 1..k) {
-            for (i in 0..n) {
-                dp[i][j] = Int.Companion.MIN_VALUE / 2
-            }
+        for (j in 0..n) {
+            dp[0][j] = 0
         }
-        // Fill dp array
-        for (j in 1..k) {
-            val maxPrev = IntArray(n + 1)
-            for (i in 0..<n + 1) {
-                maxPrev[i] =
-                    if (i == 0) {
-                        dp[0][j - 1] - prefixSum[0]
-                    } else {
-                        max(maxPrev[i - 1], dp[i][j - 1] - prefixSum[i])
-                    }
-            }
-            for (i in m..n) {
-                // Option 1: Don't include the current element in any new subarray
-                dp[i][j] = dp[i - 1][j]
-                // Option 2: Form a new subarray ending at position i
-                // Find the best starting position for the subarray
-                dp[i][j] = max(dp[i][j], prefixSum[i] + maxPrev[i - m])
+        for (i in 1..k) {
+            var best = Int.MIN_VALUE
+            for (j in (i * m)..n) {
+                best = maxOf(best, dp[i - 1][j - m] - ps[j - m])
+                dp[i][j] = maxOf(dp[i][j - 1], ps[j] + best)
             }
         }
-        return dp[n][k]
+        return dp[k][n]
     }
 }
 ```

src/main/kotlin/g3501_3600/s3536_maximum_product_of_two_digits/readme.md

@@ -0,0 +1,81 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3536\. Maximum Product of Two Digits
+
+Easy
+
+You are given a positive integer `n`.
+
+Return the **maximum** product of any two digits in `n`.
+
+**Note:** You may use the **same** digit twice if it appears more than once in `n`.
+
+**Example 1:**
+
+**Input:** n = 31
+
+**Output:** 3
+
+**Explanation:**
+
+*   The digits of `n` are `[3, 1]`.
+*   The possible products of any two digits are: `3 * 1 = 3`.
+*   The maximum product is 3.
+
+**Example 2:**
+
+**Input:** n = 22
+
+**Output:** 4
+
+**Explanation:**
+
+*   The digits of `n` are `[2, 2]`.
+*   The possible products of any two digits are: `2 * 2 = 4`.
+*   The maximum product is 4.
+
+**Example 3:**
+
+**Input:** n = 124
+
+**Output:** 8
+
+**Explanation:**
+
+*   The digits of `n` are `[1, 2, 4]`.
+*   The possible products of any two digits are: `1 * 2 = 2`, `1 * 4 = 4`, `2 * 4 = 8`.
+*   The maximum product is 8.
+
+**Constraints:**
+
+*   <code>10 <= n <= 10<sup>9</sup></code>
+
+## Solution
+
+```kotlin
+class Solution {
+    fun maxProduct(n: Int): Int {
+        var n = n
+        var m1 = n % 10
+        n /= 10
+        var m2 = n % 10
+        n /= 10
+        while (n > 0) {
+            val a = n % 10
+            if (a > m1) {
+                if (m1 > m2) {
+                    m2 = m1
+                }
+                m1 = a
+            } else {
+                if (a > m2) {
+                    m2 = a
+                }
+            }
+            n /= 10
+        }
+        return m1 * m2
+    }
+}
+```

src/main/kotlin/g3501_3600/s3537_fill_a_special_grid/readme.md

@@ -0,0 +1,104 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3537\. Fill a Special Grid
+
+Medium
+
+You are given a non-negative integer `n` representing a <code>2<sup>n</sup> x 2<sup>n</sup></code> grid. You must fill the grid with integers from 0 to <code>2<sup>2n</sup> - 1</code> to make it **special**. A grid is **special** if it satisfies **all** the following conditions:
+
+*   All numbers in the top-right quadrant are smaller than those in the bottom-right quadrant.
+*   All numbers in the bottom-right quadrant are smaller than those in the bottom-left quadrant.
+*   All numbers in the bottom-left quadrant are smaller than those in the top-left quadrant.
+*   Each of its quadrants is also a special grid.
+
+Return the **special** <code>2<sup>n</sup> x 2<sup>n</sup></code> grid.
+
+**Note**: Any 1x1 grid is special.
+
+**Example 1:**
+
+**Input:** n = 0
+
+**Output:** [[0]]
+
+**Explanation:**
+
+The only number that can be placed is 0, and there is only one possible position in the grid.
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** [[3,0],[2,1]]
+
+**Explanation:**
+
+The numbers in each quadrant are:
+
+*   Top-right: 0
+*   Bottom-right: 1
+*   Bottom-left: 2
+*   Top-left: 3
+
+Since `0 < 1 < 2 < 3`, this satisfies the given constraints.
+
+**Example 3:**
+
+**Input:** n = 2
+
+**Output:** [[15,12,3,0],[14,13,2,1],[11,8,7,4],[10,9,6,5]]
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2025/03/05/4123example3p1drawio.png)
+
+The numbers in each quadrant are:
+
+*   Top-right: 3, 0, 2, 1
+*   Bottom-right: 7, 4, 6, 5
+*   Bottom-left: 11, 8, 10, 9
+*   Top-left: 15, 12, 14, 13
+*   `max(3, 0, 2, 1) < min(7, 4, 6, 5)`
+*   `max(7, 4, 6, 5) < min(11, 8, 10, 9)`
+*   `max(11, 8, 10, 9) < min(15, 12, 14, 13)`
+
+This satisfies the first three requirements. Additionally, each quadrant is also a special grid. Thus, this is a special grid.
+
+**Constraints:**
+
+*   `0 <= n <= 10`
+
+## Solution
+
+```kotlin
+import kotlin.math.pow
+
+class Solution {
+    fun specialGrid(n: Int): Array<IntArray> {
+        if (n == 0) {
+            return arrayOf<IntArray>(intArrayOf(0))
+        }
+        val len = 2.0.pow(n.toDouble()).toInt()
+        val ans = Array<IntArray>(len) { IntArray(len) }
+        val num = intArrayOf(2.0.pow(2.0 * n).toInt() - 1)
+        backtrack(ans, len, len, 0, 0, num)
+        return ans
+    }
+
+    private fun backtrack(ans: Array<IntArray>, m: Int, n: Int, x: Int, y: Int, num: IntArray) {
+        if (m == 2 && n == 2) {
+            ans[x][y] = num[0]
+            ans[x + 1][y] = num[0] - 1
+            ans[x + 1][y + 1] = num[0] - 2
+            ans[x][y + 1] = num[0] - 3
+            num[0] -= 4
+            return
+        }
+        backtrack(ans, m / 2, n / 2, x, y, num)
+        backtrack(ans, m / 2, n / 2, x + m / 2, y, num)
+        backtrack(ans, m / 2, n / 2, x + m / 2, y + n / 2, num)
+        backtrack(ans, m / 2, n / 2, x, y + n / 2, num)
+    }
+}
+```