Added tasks 3627-3642

Author: javadev

README.md

@@ -769,7 +769,7 @@
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0200 |[Number of Islands](src/main/kotlin/g0101_0200/s0200_number_of_islands)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find, Big_O_Time_O(M\*N)_Space_O(M\*N) | 252 | 95.41
-| 0133 |[Clone Graph](src/main/kotlin/g0101_0200/s0133_clone_graph)| Medium | Hash_Table, Depth_First_Search, Breadth_First_Search, Graph | 351 | 60.91
+| 0133 |[Clone Graph](src/main/kotlin/g0101_0200/s0133_clone_graph)| Medium | Hash_Table, Depth_First_Search, Breadth_First_Search, Graph | 133 | 88.96
 | 0417 |[Pacific Atlantic Water Flow](src/main/kotlin/g0401_0500/s0417_pacific_atlantic_water_flow)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix | 319 | 100.00
 
 #### Udemy Dynamic Programming
@@ -973,7 +973,7 @@
 |-|-|-|-|-|-
 | 0200 |[Number of Islands](src/main/kotlin/g0101_0200/s0200_number_of_islands)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find, Big_O_Time_O(M\*N)_Space_O(M\*N) | 252 | 95.41
 | 0130 |[Surrounded Regions](src/main/kotlin/g0101_0200/s0130_surrounded_regions)| Medium | Top_Interview_Questions, Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find | 355 | 84.42
-| 0133 |[Clone Graph](src/main/kotlin/g0101_0200/s0133_clone_graph)| Medium | Hash_Table, Depth_First_Search, Breadth_First_Search, Graph | 351 | 60.91
+| 0133 |[Clone Graph](src/main/kotlin/g0101_0200/s0133_clone_graph)| Medium | Hash_Table, Depth_First_Search, Breadth_First_Search, Graph | 133 | 88.96
 | 0399 |[Evaluate Division](src/main/kotlin/g0301_0400/s0399_evaluate_division)| Medium | Array, Depth_First_Search, Breadth_First_Search, Graph, Union_Find, Shortest_Path, LeetCode_75_Graphs/DFS | 183 | 91.49
 | 0207 |[Course Schedule](src/main/kotlin/g0201_0300/s0207_course_schedule)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Graph, Topological_Sort, Big_O_Time_O(N)_Space_O(N) | 183 | 92.07
 | 0210 |[Course Schedule II](src/main/kotlin/g0201_0300/s0210_course_schedule_ii)| Medium | Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Graph, Topological_Sort | 266 | 96.32
@@ -2088,6 +2088,19 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3642 |[Find Books with Polarized Opinions](src/main/kotlin/g3601_3700/s3642_find_books_with_polarized_opinions)| Easy | Database | 490 | 100.00
+| 3640 |[Trionic Array II](src/main/kotlin/g3601_3700/s3640_trionic_array_ii)| Hard | Weekly_Contest_461 | 7 | 100.00
+| 3639 |[Minimum Time to Activate String](src/main/kotlin/g3601_3700/s3639_minimum_time_to_activate_string)| Medium | Weekly_Contest_461 | 160 | 100.00
+| 3638 |[Maximum Balanced Shipments](src/main/kotlin/g3601_3700/s3638_maximum_balanced_shipments)| Medium | Weekly_Contest_461 | 5 | 100.00
+| 3637 |[Trionic Array I](src/main/kotlin/g3601_3700/s3637_trionic_array_i)| Easy | Weekly_Contest_461 | 1 | 100.00
+| 3636 |[Threshold Majority Queries](src/main/kotlin/g3601_3700/s3636_threshold_majority_queries)| Hard | Biweekly_Contest_162 | 848 | 100.00
+| 3635 |[Earliest Finish Time for Land and Water Rides II](src/main/kotlin/g3601_3700/s3635_earliest_finish_time_for_land_and_water_rides_ii)| Medium | Biweekly_Contest_162 | 5 | 100.00
+| 3634 |[Minimum Removals to Balance Array](src/main/kotlin/g3601_3700/s3634_minimum_removals_to_balance_array)| Medium | Biweekly_Contest_162 | 43 | 100.00
+| 3633 |[Earliest Finish Time for Land and Water Rides I](src/main/kotlin/g3601_3700/s3633_earliest_finish_time_for_land_and_water_rides_i)| Easy | Biweekly_Contest_162 | 15 | 100.00
+| 3630 |[Partition Array for Maximum XOR and AND](src/main/kotlin/g3601_3700/s3630_partition_array_for_maximum_xor_and_and)| Hard | Array, Math, Greedy, Enumeration, Weekly_Contest_460 | 57 | 100.00
+| 3629 |[Minimum Jumps to Reach End via Prime Teleportation](src/main/kotlin/g3601_3700/s3629_minimum_jumps_to_reach_end_via_prime_teleportation)| Medium | Weekly_Contest_460 | 406 | 100.00
+| 3628 |[Maximum Number of Subsequences After One Inserting](src/main/kotlin/g3601_3700/s3628_maximum_number_of_subsequences_after_one_inserting)| Medium | Weekly_Contest_460 | 13 | 100.00
+| 3627 |[Maximum Median Sum of Subsequences of Size 3](src/main/kotlin/g3601_3700/s3627_maximum_median_sum_of_subsequences_of_size_3)| Medium | Weekly_Contest_460 | 46 | 91.67
 | 3626 |[Find Stores with Inventory Imbalance](src/main/kotlin/g3601_3700/s3626_find_stores_with_inventory_imbalance)| Medium | Database | 516 | 100.00
 | 3625 |[Count Number of Trapezoids II](src/main/kotlin/g3601_3700/s3625_count_number_of_trapezoids_ii)| Hard | Array, Hash_Table, Math, Geometry, Weekly_Contest_459 | 377 | 100.00
 | 3624 |[Number of Integers With Popcount-Depth Equal to K II](src/main/kotlin/g3601_3700/s3624_number_of_integers_with_popcount_depth_equal_to_k_ii)| Hard | Array, Segment_Tree, Weekly_Contest_459 | 38 | 100.00
@@ -4856,7 +4869,7 @@
 | 0136 |[Single Number](src/main/kotlin/g0101_0200/s0136_single_number)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Bit_Manipulation, LeetCode_75_Bit_Manipulation, Data_Structure_II_Day_1_Array, Algorithm_I_Day_14_Bit_Manipulation, Udemy_Integers, Top_Interview_150_Bit_Manipulation, Big_O_Time_O(N)_Space_O(1) | 344 | 83.63
 | 0135 |[Candy](src/main/kotlin/g0101_0200/s0135_candy)| Hard | Array, Greedy, Top_Interview_150_Array/String | 466 | 58.33
 | 0134 |[Gas Station](src/main/kotlin/g0101_0200/s0134_gas_station)| Medium | Top_Interview_Questions, Array, Greedy, Top_Interview_150_Array/String | 545 | 70.18
-| 0133 |[Clone Graph](src/main/kotlin/g0101_0200/s0133_clone_graph)| Medium | Hash_Table, Depth_First_Search, Breadth_First_Search, Graph, Udemy_Graph, Top_Interview_150_Graph_General | 351 | 60.91
+| 0133 |[Clone Graph](src/main/kotlin/g0101_0200/s0133_clone_graph)| Medium | Hash_Table, Depth_First_Search, Breadth_First_Search, Graph, Udemy_Graph, Top_Interview_150_Graph_General | 133 | 88.96
 | 0132 |[Palindrome Partitioning II](src/main/kotlin/g0101_0200/s0132_palindrome_partitioning_ii)| Hard | String, Dynamic_Programming | 290 | 100.00
 | 0131 |[Palindrome Partitioning](src/main/kotlin/g0101_0200/s0131_palindrome_partitioning)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Dynamic_Programming, Backtracking, Big_O_Time_O(N\*2^N)_Space_O(2^N\*N) | 820 | 87.27
 | 0130 |[Surrounded Regions](src/main/kotlin/g0101_0200/s0130_surrounded_regions)| Medium | Top_Interview_Questions, Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find, Algorithm_II_Day_8_Breadth_First_Search_Depth_First_Search, Top_Interview_150_Graph_General | 355 | 84.42

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

@@ -68,7 +68,7 @@ The given node will always be the first node with `val = 1`. You must return the
 ## Solution
 
 ```kotlin
-import com_github_leetcode.neighbors.Node
+import com_github_leetcode.Node
 
 /*
  * Definition for a Node.
@@ -89,11 +89,10 @@ class Solution {
         }
         val newNode = Node(node.`val`)
         processedNodes[node] = newNode
-        newNode.neighbors = ArrayList()
         for (neighbor in node.neighbors) {
-            val clonedNeighbor: Node? = cloneGraph(neighbor, processedNodes)
+            val clonedNeighbor = cloneGraph(neighbor, processedNodes)
             if (clonedNeighbor != null) {
-                newNode.neighbors.add(clonedNeighbor)
+                (newNode.neighbors as ArrayList).add(clonedNeighbor)
             }
         }
         return newNode

src/main/kotlin/g3601_3700/s3627_maximum_median_sum_of_subsequences_of_size_3/readme.md

@@ -0,0 +1,65 @@
+[![](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)
+
+## 3627\. Maximum Median Sum of Subsequences of Size 3
+
+Medium
+
+You are given an integer array `nums` with a length divisible by 3.
+
+You want to make the array empty in steps. In each step, you can select any three elements from the array, compute their **median**, and remove the selected elements from the array.
+
+The **median** of an odd-length sequence is defined as the middle element of the sequence when it is sorted in non-decreasing order.
+
+Return the **maximum** possible sum of the medians computed from the selected elements.
+
+**Example 1:**
+
+**Input:** nums = [2,1,3,2,1,3]
+
+**Output:** 5
+
+**Explanation:**
+
+*   In the first step, select elements at indices 2, 4, and 5, which have a median 3. After removing these elements, `nums` becomes `[2, 1, 2]`.
+*   In the second step, select elements at indices 0, 1, and 2, which have a median 2. After removing these elements, `nums` becomes empty.
+
+Hence, the sum of the medians is `3 + 2 = 5`.
+
+**Example 2:**
+
+**Input:** nums = [1,1,10,10,10,10]
+
+**Output:** 20
+
+**Explanation:**
+
+*   In the first step, select elements at indices 0, 2, and 3, which have a median 10. After removing these elements, `nums` becomes `[1, 10, 10]`.
+*   In the second step, select elements at indices 0, 1, and 2, which have a median 10. After removing these elements, `nums` becomes empty.
+
+Hence, the sum of the medians is `10 + 10 = 20`.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 5 * 10<sup>5</sup></code>
+*   `nums.length % 3 == 0`
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>
+
+## Solution
+
+```kotlin
+class Solution {
+    fun maximumMedianSum(nums: IntArray): Long {
+        nums.sort()
+        var i = 0
+        var j = nums.size
+        var sum = 0L
+        while (i < j) {
+            sum += nums[j - 2]
+            j = j - 2
+            i++
+        }
+        return sum
+    }
+}
+```

src/main/kotlin/g3601_3700/s3628_maximum_number_of_subsequences_after_one_inserting/readme.md

@@ -0,0 +1,95 @@
+[![](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)
+
+## 3628\. Maximum Number of Subsequences After One Inserting
+
+Medium
+
+You are given a string `s` consisting of uppercase English letters.
+
+You are allowed to insert **at most one** uppercase English letter at **any** position (including the beginning or end) of the string.
+
+Return the **maximum** number of `"LCT"` subsequences that can be formed in the resulting string after **at most one insertion**.
+
+**Example 1:**
+
+**Input:** s = "LMCT"
+
+**Output:** 2
+
+**Explanation:**
+
+We can insert a `"L"` at the beginning of the string s to make `"LLMCT"`, which has 2 subsequences, at indices [0, 3, 4] and [1, 3, 4].
+
+**Example 2:**
+
+**Input:** s = "LCCT"
+
+**Output:** 4
+
+**Explanation:**
+
+We can insert a `"L"` at the beginning of the string s to make `"LLCCT"`, which has 4 subsequences, at indices [0, 2, 4], [0, 3, 4], [1, 2, 4] and [1, 3, 4].
+
+**Example 3:**
+
+**Input:** s = "L"
+
+**Output:** 0
+
+**Explanation:**
+
+Since it is not possible to obtain the subsequence `"LCT"` by inserting a single letter, the result is 0.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of uppercase English letters.
+
+## Solution
+
+```kotlin
+class Solution {
+    fun numOfSubsequences(s: String): Long {
+        var tc: Long = 0
+        val chs = s.toCharArray()
+        for (c in chs) {
+            tc += (if (c == 'T') 1 else 0).toLong()
+        }
+        var ls: Long = 0
+        var cs: Long = 0
+        var lcf: Long = 0
+        var ctf: Long = 0
+        var lct: Long = 0
+        var ocg: Long = 0
+        var tp: Long = 0
+        for (curr in chs) {
+            val rt = tc - tp
+            val cg = ls * rt
+            ocg = if (cg > ocg) cg else ocg
+            if (curr == 'L') {
+                ls++
+            } else {
+                if (curr == 'C') {
+                    cs++
+                    lcf += ls
+                } else {
+                    if (curr == 'T') {
+                        lct += lcf
+                        ctf += cs
+                        tp++
+                    }
+                }
+            }
+        }
+        val fcg = ls * (tc - tp)
+        ocg = if (fcg > ocg) fcg else ocg
+        var maxi: Long = 0
+        val bo = longArrayOf(lcf, ctf, ocg)
+        for (op in bo) {
+            maxi = if (op > maxi) op else maxi
+        }
+        return lct + maxi
+    }
+}
+```

src/main/kotlin/g3601_3700/s3629_minimum_jumps_to_reach_end_via_prime_teleportation/readme.md

@@ -0,0 +1,150 @@
+[![](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)
+
+## 3629\. Minimum Jumps to Reach End via Prime Teleportation
+
+Medium
+
+You are given an integer array `nums` of length `n`.
+
+You start at index 0, and your goal is to reach index `n - 1`.
+
+From any index `i`, you may perform one of the following operations:
+
+*   **Adjacent Step**: Jump to index `i + 1` or `i - 1`, if the index is within bounds.
+*   **Prime Teleportation**: If `nums[i]` is a prime number `p`, you may instantly jump to any index `j != i` such that `nums[j] % p == 0`.
+
+Return the **minimum** number of jumps required to reach index `n - 1`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,4,6]
+
+**Output:** 2
+
+**Explanation:**
+
+One optimal sequence of jumps is:
+
+*   Start at index `i = 0`. Take an adjacent step to index 1.
+*   At index `i = 1`, `nums[1] = 2` is a prime number. Therefore, we teleport to index `i = 3` as `nums[3] = 6` is divisible by 2.
+
+Thus, the answer is 2.
+
+**Example 2:**
+
+**Input:** nums = [2,3,4,7,9]
+
+**Output:** 2
+
+**Explanation:**
+
+One optimal sequence of jumps is:
+
+*   Start at index `i = 0`. Take an adjacent step to index `i = 1`.
+*   At index `i = 1`, `nums[1] = 3` is a prime number. Therefore, we teleport to index `i = 4` since `nums[4] = 9` is divisible by 3.
+
+Thus, the answer is 2.
+
+**Example 3:**
+
+**Input:** nums = [4,6,5,8]
+
+**Output:** 3
+
+**Explanation:**
+
+*   Since no teleportation is possible, we move through `0 → 1 → 2 → 3`. Thus, the answer is 3.
+
+**Constraints:**
+
+*   <code>1 <= n == nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>6</sup></code>
+
+## Solution
+
+```kotlin
+import java.util.ArrayDeque
+import kotlin.math.max
+
+class Solution {
+    fun minJumps(nums: IntArray): Int {
+        val n = nums.size
+        if (n == 1) {
+            return 0
+        }
+        var maxVal = 0
+        for (v in nums) {
+            maxVal = max(maxVal, v)
+        }
+        val isPrime = sieve(maxVal)
+        val posOfValue: Array<ArrayList<Int>> = Array<ArrayList<Int>>(maxVal + 1) { ArrayList<Int>() }
+        for (i in 0..<n) {
+            val v = nums[i]
+            posOfValue[v].add(i)
+        }
+        val primeProcessed = BooleanArray(maxVal + 1)
+        val dist = IntArray(n)
+        dist.fill(-1)
+        val q = ArrayDeque<Int>()
+        q.add(0)
+        dist[0] = 0
+        while (q.isNotEmpty()) {
+            val i: Int = q.poll()!!
+            val d = dist[i]
+            if (i == n - 1) {
+                return d
+            }
+            if (i + 1 < n && dist[i + 1] == -1) {
+                dist[i + 1] = d + 1
+                q.add(i + 1)
+            }
+            if (i - 1 >= 0 && dist[i - 1] == -1) {
+                dist[i - 1] = d + 1
+                q.add(i - 1)
+            }
+            val v = nums[i]
+            if (v <= maxVal && isPrime[v] && !primeProcessed[v]) {
+                var mult = v
+                while (mult <= maxVal) {
+                    val list = posOfValue[mult]
+                    for (idx in list) {
+                        if (dist[idx] == -1) {
+                            dist[idx] = d + 1
+                            q.add(idx)
+                        }
+                    }
+                    mult += v
+                }
+                primeProcessed[v] = true
+            }
+        }
+        return -1
+    }
+
+    private fun sieve(n: Int): BooleanArray {
+        val prime = BooleanArray(n + 1)
+        if (n >= 2) {
+            prime.fill(true)
+        }
+        if (n >= 0) {
+            prime[0] = false
+        }
+        if (n >= 1) {
+            prime[1] = false
+        }
+        var i = 2
+        while (i.toLong() * i <= n) {
+            if (prime[i]) {
+                var j = i * i
+                while (j <= n) {
+                    prime[j] = false
+                    j += i
+                }
+            }
+            i++
+        }
+        return prime
+    }
+}
+```