Added tasks 3582-3585

Author: javadev

README.md

@@ -2088,6 +2088,10 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3585 |[Find Weighted Median Node in Tree](src/main/kotlin/g3501_3600/s3585_find_weighted_median_node_in_tree)| Hard | Array, Dynamic_Programming, Tree, Binary_Search, Depth_First_Search | 123 | 100.00
+| 3584 |[Maximum Product of First and Last Elements of a Subsequence](src/main/kotlin/g3501_3600/s3584_maximum_product_of_first_and_last_elements_of_a_subsequence)| Medium | Array, Two_Pointers | 8 | 100.00
+| 3583 |[Count Special Triplets](src/main/kotlin/g3501_3600/s3583_count_special_triplets)| Medium | Array, Hash_Table, Counting | 238 | 55.56
+| 3582 |[Generate Tag for Video Caption](src/main/kotlin/g3501_3600/s3582_generate_tag_for_video_caption)| Easy | String, Simulation | 3 | 100.00
 | 3580 |[Find Consistently Improving Employees](src/main/kotlin/g3501_3600/s3580_find_consistently_improving_employees)| Medium | Database | 449 | 91.67
 | 3579 |[Minimum Steps to Convert String with Operations](src/main/kotlin/g3501_3600/s3579_minimum_steps_to_convert_string_with_operations)| Hard | String, Dynamic_Programming, Greedy | 107 | 100.00
 | 3578 |[Count Partitions With Max-Min Difference at Most K](src/main/kotlin/g3501_3600/s3578_count_partitions_with_max_min_difference_at_most_k)| Medium | Array, Dynamic_Programming, Prefix_Sum, Sliding_Window, Queue, Monotonic_Queue | 33 | 100.00

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

@@ -0,0 +1,94 @@
+[![](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)
+
+## 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 `' '`.
+
+## Solution
+
+```kotlin
+class Solution {
+    fun generateTag(caption: String): String? {
+        var caption = caption
+        val sb = StringBuilder()
+        sb.append('#')
+        var space = false
+        caption = caption.trim { it <= ' ' }
+        for (i in 0..<caption.length) {
+            val c = caption[i]
+            if (c == ' ') {
+                space = true
+            }
+            if (c >= 'A' && c <= 'Z') {
+                if (space) {
+                    space = !space
+                    sb.append(c)
+                } else {
+                    sb.append(c.lowercaseChar())
+                }
+            }
+            if (c >= 'a' && c <= 'z') {
+                if (space) {
+                    space = !space
+                    sb.append(c.uppercaseChar())
+                } else {
+                    sb.append(c)
+                }
+            }
+        }
+        if (sb.length > 100) {
+            return sb.substring(0, 100)
+        }
+        return sb.toString()
+    }
+}
+```

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

@@ -0,0 +1,94 @@
+[![](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)
+
+## 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>
+
+## Solution
+
+```kotlin
+class Solution {
+    fun specialTriplets(nums: IntArray): Int {
+        val mod = 1_000_000_007
+        var res = 0
+        val left = mutableMapOf<Int, Int>()
+        val right = mutableMapOf<Int, Int>()
+        for (num in nums) {
+            right[num] = right.getOrDefault(num, 0) + 1
+        }
+        for (num in nums) {
+            right[num] = right[num]!! - 1
+            val ci = left.getOrDefault(num * 2, 0)
+            val ck = right.getOrDefault(num * 2, 0)
+            res = ((res + 1L * ci * ck) % mod).toInt()
+            left[num] = left.getOrDefault(num, 0) + 1
+        }
+        return res
+    }
+}
+```

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

@@ -0,0 +1,67 @@
+[![](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)
+
+## 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`
+
+## Solution
+
+```kotlin
+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
+    }
+}
+```