Added tasks 3612-3615

Author: javadev

README.md

@@ -45,7 +45,7 @@ You can return the answer in any order.
 ```kotlin
 class Solution {
     fun twoSum(numbers: IntArray, target: Int): IntArray {
-        val indexMap = HashMap<Int, Int>()
+        val indexMap: MutableMap<Int, Int> = HashMap()
         for (i in numbers.indices) {
             val requiredNum = target - numbers[i]
             if (indexMap.containsKey(requiredNum)) {

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

@@ -47,26 +47,27 @@ Given a string `s`, find the length of the **longest substring** without repeati
 ```kotlin
 class Solution {
     fun lengthOfLongestSubstring(s: String): Int {
-        val lastIndices = IntArray(256) { -1 }
-        var maxLen = 0
-        var curLen = 0
-        var start = 0
-        for (i in s.indices) {
-            val cur = s[i]
-            if (lastIndices[cur.code] < start) {
-                lastIndices[cur.code] = i
-                curLen++
+        var i = 0
+        var j = 0
+        var longest = 0
+        // 1. if string empty, return 0
+        if (s.isEmpty()) {
+            return 0
+        }
+        while (j < s.length) {
+            // 2. if the char at index j already seen, update the longest if needs
+            if (i != j && s.substring(i, j).indexOf(s[j]) > -1) {
+                longest = Math.max(j - i, longest)
+                i++
             } else {
-                val lastIndex = lastIndices[cur.code]
-                start = lastIndex + 1
-                curLen = i - start + 1
-                lastIndices[cur.code] = i
-            }
-            if (curLen > maxLen) {
-                maxLen = curLen
+                // 3. j out of bound already, update longest
+                if (++j == s.length) {
+                    longest = Math.max(s.length - i, longest)
+                    break
+                }
             }
         }
-        return maxLen
+        return longest
     }
 }
 ```

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

@@ -55,38 +55,24 @@ The overall run time complexity should be `O(log (m+n))`.
 ## Solution
 
 ```kotlin
-import kotlin.math.max
-import kotlin.math.min
-
 class Solution {
     fun findMedianSortedArrays(nums1: IntArray, nums2: IntArray): Double {
-        if (nums2.size < nums1.size) {
-            return findMedianSortedArrays(nums2, nums1)
+        val l: MutableList<Int> = ArrayList()
+        val f: Double
+        for (j in nums1) {
+            l.add(j)
+        }
+        for (i in nums2) {
+            l.add(i)
         }
-        val n1 = nums1.size
-        val n2 = nums2.size
-        var low = 0
-        var high = n1
-        while (low <= high) {
-            val cut1 = (low + high) / 2
-            val cut2 = ((n1 + n2 + 1) / 2) - cut1
-            val l1 = if (cut1 == 0) Int.MIN_VALUE else nums1[cut1 - 1]
-            val l2 = if (cut2 == 0) Int.MIN_VALUE else nums2[cut2 - 1]
-            val r1 = if (cut1 == n1) Int.MAX_VALUE else nums1[cut1]
-            val r2 = if (cut2 == n2) Int.MAX_VALUE else nums2[cut2]
-            if (l1 <= r2 && l2 <= r1) {
-                return if ((n1 + n2) % 2 == 0) {
-                    (max(l1, l2).toDouble() + min(r1, r2).toDouble()) / 2.0
-                } else {
-                    max(l1, l2).toDouble()
-                }
-            } else if (l1 > r2) {
-                high = cut1 - 1
-            } else {
-                low = cut1 + 1
-            }
+        l.sort()
+        val k = l.size
+        f = if (k % 2 == 0) {
+            (l[k / 2 - 1] + l[k / 2]).toDouble() / 2
+        } else {
+            l[(k + 1) / 2 - 1].toDouble()
         }
-        return 0.0
+        return f
     }
 }
 ```

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

@@ -0,0 +1,146 @@
+[![](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)
+
+## 3612\. Process String with Special Operations I
+
+Medium
+
+You are given a string `s` consisting of lowercase English letters and the special characters: `*`, `#`, and `%`.
+
+Build a new string `result` by processing `s` according to the following rules from left to right:
+
+*   If the letter is a **lowercase** English letter append it to `result`.
+*   A `'*'` **removes** the last character from `result`, if it exists.
+*   A `'#'` **duplicates** the current `result` and **appends** it to itself.
+*   A `'%'` **reverses** the current `result`.
+
+Return the final string `result` after processing all characters in `s`.
+
+**Example 1:**
+
+**Input:** s = "a#b%\*"
+
+**Output:** "ba"
+
+**Explanation:**
+
+`i`
+
+`s[i]`
+
+Operation
+
+Current `result`
+
+0
+
+`'a'`
+
+Append `'a'`
+
+`"a"`
+
+1
+
+`'#'`
+
+Duplicate `result`
+
+`"aa"`
+
+2
+
+`'b'`
+
+Append `'b'`
+
+`"aab"`
+
+3
+
+`'%'`
+
+Reverse `result`
+
+`"baa"`
+
+4
+
+`'*'`
+
+Remove the last character
+
+`"ba"`
+
+Thus, the final `result` is `"ba"`.
+
+**Example 2:**
+
+**Input:** s = "z\*#"
+
+**Output:** ""
+
+**Explanation:**
+
+`i`
+
+`s[i]`
+
+Operation
+
+Current `result`
+
+0
+
+`'z'`
+
+Append `'z'`
+
+`"z"`
+
+1
+
+`'*'`
+
+Remove the last character
+
+`""`
+
+2
+
+`'#'`
+
+Duplicate the string
+
+`""`
+
+Thus, the final `result` is `""`.
+
+**Constraints:**
+
+*   `1 <= s.length <= 20`
+*   `s` consists of only lowercase English letters and special characters `*`, `#`, and `%`.
+
+## Solution
+
+```kotlin
+class Solution {
+    fun processStr(s: String): String {
+        val res = StringBuilder()
+        for (c in s.toCharArray()) {
+            if (c != '*' && c != '#' && c != '%') {
+                res.append(c)
+            } else if (c == '#') {
+                res.append(res)
+            } else if (c == '%') {
+                res.reverse()
+            } else {
+                if (res.isNotEmpty()) {
+                    res.deleteCharAt(res.length - 1)
+                }
+            }
+        }
+        return res.toString()
+    }
+}
+```

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

@@ -0,0 +1,112 @@
+[![](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)
+
+## 3613\. Minimize Maximum Component Cost
+
+Medium
+
+You are given an undirected connected graph with `n` nodes labeled from 0 to `n - 1` and a 2D integer array `edges` where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, w<sub>i</sub>]</code> denotes an undirected edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with weight <code>w<sub>i</sub></code>, and an integer `k`.
+
+You are allowed to remove any number of edges from the graph such that the resulting graph has **at most** `k` connected components.
+
+The **cost** of a component is defined as the **maximum** edge weight in that component. If a component has no edges, its cost is 0.
+
+Return the **minimum** possible value of the **maximum** cost among all components **after such removals**.
+
+**Example 1:**
+
+**Input:** n = 5, edges = \[\[0,1,4],[1,2,3],[1,3,2],[3,4,6]], k = 2
+
+**Output:** 4
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2025/04/19/minimizemaximumm.jpg)
+
+*   Remove the edge between nodes 3 and 4 (weight 6).
+*   The resulting components have costs of 0 and 4, so the overall maximum cost is 4.
+
+**Example 2:**
+
+**Input:** n = 4, edges = \[\[0,1,5],[1,2,5],[2,3,5]], k = 1
+
+**Output:** 5
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2025/04/19/minmax2.jpg)
+
+*   No edge can be removed, since allowing only one component (`k = 1`) requires the graph to stay fully connected.
+*   That single component’s cost equals its largest edge weight, which is 5.
+
+**Constraints:**
+
+*   <code>1 <= n <= 5 * 10<sup>4</sup></code>
+*   <code>0 <= edges.length <= 10<sup>5</sup></code>
+*   `edges[i].length == 3`
+*   <code>0 <= u<sub>i</sub>, v<sub>i</sub> < n</code>
+*   <code>1 <= w<sub>i</sub> <= 10<sup>6</sup></code>
+*   `1 <= k <= n`
+*   The input graph is connected.
+
+## Solution
+
+```kotlin
+import kotlin.math.max
+
+class Solution {
+    fun minCost(ui: Int, pl: Array<IntArray>, zx: Int): Int {
+        var rt = 0
+        var gh = 0
+        var i = 0
+        while (i < pl.size) {
+            gh = max(gh, pl[i][2])
+            i++
+        }
+        while (rt < gh) {
+            val ty = rt + (gh - rt) / 2
+            if (dfgh(ui, pl, ty, zx)) {
+                gh = ty
+            } else {
+                rt = ty + 1
+            }
+        }
+        return rt
+    }
+
+    private fun dfgh(ui: Int, pl: Array<IntArray>, jk: Int, zx: Int): Boolean {
+        val wt = IntArray(ui)
+        var i = 0
+        while (i < ui) {
+            wt[i] = i
+            i++
+        }
+        var er = ui
+        i = 0
+        while (i < pl.size) {
+            val df = pl[i]
+            if (df[2] > jk) {
+                i++
+                continue
+            }
+            val u = cvb(wt, df[0])
+            val v = cvb(wt, df[1])
+            if (u != v) {
+                wt[u] = v
+                er--
+            }
+            i++
+        }
+        return er <= zx
+    }
+
+    private fun cvb(wt: IntArray, i: Int): Int {
+        var i = i
+        while (wt[i] != i) {
+            wt[i] = wt[wt[i]]
+            i = wt[i]
+        }
+        return i
+    }
+}
+```