Added tasks 3582-3585

Author: javadev

src/main/kotlin/g3501_3600/s3582_generate_tag_for_video_caption/Solution.kt

@@ -0,0 +1,38 @@
+package g3501_3600.s3582_generate_tag_for_video_caption
+
+// #Easy #2025_06_16_Time_12_ms_(100.00%)_Space_45.47_MB_(100.00%)
+
+import java.util.Locale
+
+class Solution {
+    fun generateTag(caption: String): String? {
+        if (caption.trim { it <= ' ' }.isEmpty()) {
+            return "#"
+        }
+        val arr = caption.trim { it <= ' ' }.split("\\s+".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+        val res = StringBuilder("#")
+        var firstWord = arr[0]
+        firstWord =
+            (
+                firstWord.substring(0, 1).lowercase(Locale.getDefault()) +
+                    (if (firstWord.length > 1) firstWord.substring(1).lowercase(Locale.getDefault()) else "")
+                )
+        res.append(firstWord)
+        for (i in 1..<arr.size) {
+            var w = arr[i]
+            if (w.isEmpty()) {
+                continue
+            }
+            w =
+                (
+                    w.substring(0, 1).uppercase(Locale.getDefault()) +
+                        (if (w.length > 1) w.substring(1).lowercase(Locale.getDefault()) else "")
+                    )
+            res.append(w)
+            if (res.length >= 100) {
+                break
+            }
+        }
+        return if (res.length > 100) res.substring(0, 100) else res.toString()
+    }
+}

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

@@ -0,0 +1,51 @@
+3582\. Generate Tag for Video Caption
+
+Easy
+
+You are given a string `caption` representing the caption for a video.
+
+The following actions must be performed **in order** to generate a **valid tag** for the video:
+
+1.  **Combine all words** in the string into a single _camelCase string_ prefixed with `'#'`. A _camelCase string_ is one where the first letter of all words _except_ the first one is capitalized. All characters after the first character in **each** word must be lowercase.
+    
+2.  **Remove** all characters that are not an English letter, **except** the first `'#'`.
+    
+3.  **Truncate** the result to a maximum of 100 characters.
+    
+
+Return the **tag** after performing the actions on `caption`.
+
+**Example 1:**
+
+**Input:** caption = "Leetcode daily streak achieved"
+
+**Output:** "#leetcodeDailyStreakAchieved"
+
+**Explanation:**
+
+The first letter for all words except `"leetcode"` should be capitalized.
+
+**Example 2:**
+
+**Input:** caption = "can I Go There"
+
+**Output:** "#canIGoThere"
+
+**Explanation:**
+
+The first letter for all words except `"can"` should be capitalized.
+
+**Example 3:**
+
+**Input:** caption = "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"
+
+**Output:** "#hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"
+
+**Explanation:**
+
+Since the first word has length 101, we need to truncate the last two letters from the word.
+
+**Constraints:**
+
+*   `1 <= caption.length <= 150`
+*   `caption` consists only of English letters and `' '`.

src/main/kotlin/g3501_3600/s3583_count_special_triplets/Solution.kt

@@ -0,0 +1,23 @@
+package g3501_3600.s3583_count_special_triplets
+
+// #Medium #2025_06_16_Time_250_ms_(100.00%)_Space_62.22_MB_(100.00%)
+
+class Solution {
+    fun specialTriplets(nums: IntArray): Int {
+        val mod = 1000000007
+        var res = 0
+        val left: MutableMap<Int, Int> = HashMap()
+        val right: MutableMap<Int, Int> = HashMap()
+        for (num in nums) {
+            right.put(num, right.getOrDefault(num, 0) + 1)
+        }
+        for (num in nums) {
+            right.put(num, right[num]!! - 1)
+            val ci: Int = left.getOrDefault(num * 2, 0)
+            val ck: Int = right.getOrDefault(num * 2, 0)
+            res = (res + ci * ck) % mod
+            left.put(num, left.getOrDefault(num, 0) + 1)
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,67 @@
+3583\. Count Special Triplets
+
+Medium
+
+You are given an integer array `nums`.
+
+A **special triplet** is defined as a triplet of indices `(i, j, k)` such that:
+
+*   `0 <= i < j < k < n`, where `n = nums.length`
+*   `nums[i] == nums[j] * 2`
+*   `nums[k] == nums[j] * 2`
+
+Return the total number of **special triplets** in the array.
+
+Since the answer may be large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** nums = [6,3,6]
+
+**Output:** 1
+
+**Explanation:**
+
+The only special triplet is `(i, j, k) = (0, 1, 2)`, where:
+
+*   `nums[0] = 6`, `nums[1] = 3`, `nums[2] = 6`
+*   `nums[0] = nums[1] * 2 = 3 * 2 = 6`
+*   `nums[2] = nums[1] * 2 = 3 * 2 = 6`
+
+**Example 2:**
+
+**Input:** nums = [0,1,0,0]
+
+**Output:** 1
+
+**Explanation:**
+
+The only special triplet is `(i, j, k) = (0, 2, 3)`, where:
+
+*   `nums[0] = 0`, `nums[2] = 0`, `nums[3] = 0`
+*   `nums[0] = nums[2] * 2 = 0 * 2 = 0`
+*   `nums[3] = nums[2] * 2 = 0 * 2 = 0`
+
+**Example 3:**
+
+**Input:** nums = [8,4,2,8,4]
+
+**Output:** 2
+
+**Explanation:**
+
+There are exactly two special triplets:
+
+*   `(i, j, k) = (0, 1, 3)`
+    *   `nums[0] = 8`, `nums[1] = 4`, `nums[3] = 8`
+    *   `nums[0] = nums[1] * 2 = 4 * 2 = 8`
+    *   `nums[3] = nums[1] * 2 = 4 * 2 = 8`
+*   `(i, j, k) = (1, 2, 4)`
+    *   `nums[1] = 4`, `nums[2] = 2`, `nums[4] = 4`
+    *   `nums[1] = nums[2] * 2 = 2 * 2 = 4`
+    *   `nums[4] = nums[2] * 2 = 2 * 2 = 4`
+
+**Constraints:**
+
+*   <code>3 <= n == nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>5</sup></code>

src/main/kotlin/g3501_3600/s3584_maximum_product_of_first_and_last_elements_of_a_subsequence/Solution.kt

@@ -0,0 +1,20 @@
+package g3501_3600.s3584_maximum_product_of_first_and_last_elements_of_a_subsequence
+
+// #Medium #2025_06_16_Time_4_ms_(87.17%)_Space_61.31_MB_(100.00%)
+
+import kotlin.math.max
+import kotlin.math.min
+
+class Solution {
+    fun maximumProduct(nums: IntArray, m: Int): Long {
+        var ma = nums[0].toLong()
+        var mi = nums[0].toLong()
+        var res = nums[0].toLong() * nums[m - 1]
+        for (i in m - 1..<nums.size) {
+            ma = max(ma, nums[i - m + 1].toLong())
+            mi = min(mi, nums[i - m + 1].toLong())
+            res = max(res, max(mi * nums[i], ma * nums[i]))
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,43 @@
+3584\. Maximum Product of First and Last Elements of a Subsequence
+
+Medium
+
+You are given an integer array `nums` and an integer `m`.
+
+Return the **maximum** product of the first and last elements of any ****subsequences**** of `nums` of size `m`.
+
+**Example 1:**
+
+**Input:** nums = [-1,-9,2,3,-2,-3,1], m = 1
+
+**Output:** 81
+
+**Explanation:**
+
+The subsequence `[-9]` has the largest product of the first and last elements: `-9 * -9 = 81`. Therefore, the answer is 81.
+
+**Example 2:**
+
+**Input:** nums = [1,3,-5,5,6,-4], m = 3
+
+**Output:** 20
+
+**Explanation:**
+
+The subsequence `[-5, 6, -4]` has the largest product of the first and last elements.
+
+**Example 3:**
+
+**Input:** nums = [2,-1,2,-6,5,2,-5,7], m = 2
+
+**Output:** 35
+
+**Explanation:**
+
+The subsequence `[5, 7]` has the largest product of the first and last elements.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code>
+*   `1 <= m <= nums.length`

src/main/kotlin/g3501_3600/s3585_find_weighted_median_node_in_tree/Solution.kt

@@ -0,0 +1,122 @@
+package g3501_3600.s3585_find_weighted_median_node_in_tree
+
+// #Hard #2025_06_16_Time_162_ms_(100.00%)_Space_141.58_MB_(100.00%)
+
+class Solution {
+    private var log = 0
+    private lateinit var dist: LongArray
+    private lateinit var depth: IntArray
+    private lateinit var up: Array<IntArray>
+
+    fun findMedian(n: Int, edges: Array<IntArray>, queries: Array<IntArray>): IntArray {
+        val adj: MutableList<MutableList<IntArray>?> = ArrayList<MutableList<IntArray>?>()
+        for (i in 0..<n) {
+            adj.add(ArrayList<IntArray>())
+        }
+        for (edge in edges) {
+            adj[edge[0]]!!.add(intArrayOf(edge[1], edge[2]))
+            adj[edge[1]]!!.add(intArrayOf(edge[0], edge[2]))
+        }
+        dist = LongArray(n)
+        depth = IntArray(n)
+        log = 0
+        while (1 shl log < n) {
+            log++
+        }
+        up = Array(n) { IntArray(log) }
+        for (u in up) {
+            u.fill(-1)
+        }
+        dfs(0, -1, adj, 0, 0)
+        val ans = IntArray(queries.size)
+        for (i in queries.indices) {
+            val query = queries[i]
+            var first = query[0]
+            var second = query[1]
+            val distance = getDistance(first, second)
+            var needed = (distance + 1) / 2
+            val mid = lca(first, second)
+            if (getDistance(first, mid) < needed) {
+                needed -= getDistance(first, mid)
+                first = mid
+            } else {
+                second = mid
+            }
+            if (depth[first] <= depth[second]) {
+                var curDistance = getDistance(first, second)
+                for (j in log - 1 downTo 0) {
+                    if (up[second][j] == -1 ||
+                        curDistance - getDistance(up[second][j], second) < needed
+                    ) {
+                        continue
+                    }
+                    curDistance -= getDistance(up[second][j], second)
+                    second = up[second][j]
+                }
+                ans[i] = second
+            } else {
+                var curDistance: Long = 0
+                for (j in log - 1 downTo 0) {
+                    if (up[first][j] == -1 ||
+                        curDistance + getDistance(up[first][j], first) >= needed
+                    ) {
+                        continue
+                    }
+                    curDistance += getDistance(up[first][j], first)
+                    first = up[first][j]
+                }
+                ans[i] = up[first][0]
+            }
+        }
+        return ans
+    }
+
+    private fun getDistance(from: Int, to: Int): Long {
+        if (from == to) {
+            return 0
+        }
+        val ancesor = lca(from, to)
+        return dist[from] + dist[to] - 2 * dist[ancesor]
+    }
+
+    private fun lca(first: Int, second: Int): Int {
+        var first = first
+        var second = second
+        if (depth[first] < depth[second]) {
+            return lca(second, first)
+        }
+        for (i in log - 1 downTo 0) {
+            if (depth[first] - (1 shl i) >= depth[second]) {
+                first = up[first][i]
+            }
+        }
+        if (first == second) {
+            return second
+        }
+        for (i in log - 1 downTo 0) {
+            if (depth[first] != -1 && up[first][i] != up[second][i]) {
+                first = up[first][i]
+                second = up[second][i]
+            }
+        }
+        first = up[first][0]
+        return first
+    }
+
+    private fun dfs(current: Int, parent: Int, adj: MutableList<MutableList<IntArray>?>, curDist: Long, curDepth: Int) {
+        up[current][0] = parent
+        for (i in 1..<log) {
+            if (up[current][i - 1] != -1) {
+                up[current][i] = up[up[current][i - 1]][i - 1]
+            }
+        }
+        dist[current] = curDist
+        depth[current] = curDepth
+        for (next in adj[current]!!) {
+            if (next[0] == parent) {
+                continue
+            }
+            dfs(next[0], current, adj, curDist + next[1], curDepth + 1)
+        }
+    }
+}