Updated tasks

Author: javadev

src/main/kotlin/g3601_3700/s3675_minimum_operations_to_transform_string/Solution.kt

@@ -1,22 +1,23 @@
 package g3601_3700.s3675_minimum_operations_to_transform_string
 
-// #Medium #Weekly_Contest_466 #2025_09_07_Time_84_ms_(100.00%)_Space_56.99_MB_(100.00%)
+// #Medium #Weekly_Contest_466 #2025_09_14_Time_6_ms_(97.92%)_Space_57.75_MB_(43.75%)
 
 class Solution {
     fun minOperations(s: String): Int {
-        val set: MutableSet<Char> = HashSet<Char>()
-        for (ch in s.toCharArray()) {
-            set.add(ch)
-        }
-        if (set.size == 1 && set.contains('a')) {
-            return 0
-        }
-        var minCh = 'z'
-        for (ch in s.toCharArray()) {
-            if (ch != 'a' && ch < minCh) {
-                minCh = ch
+        val n = s.length
+        var ans = 0
+        for (i in 0..<n) {
+            val c = s.get(i)
+            if (c != 'a') {
+                val ops = 'z'.code - c.code + 1
+                if (ops > ans) {
+                    ans = ops
+                }
+                if (ops == 25) {
+                    break
+                }
             }
         }
-        return ('z'.code - minCh.code) + 1
+        return ans
     }
 }

src/main/kotlin/g3601_3700/s3676_count_bowl_subarrays/Solution.kt

@@ -1,26 +1,25 @@
 package g3601_3700.s3676_count_bowl_subarrays
 
-// #Medium #Weekly_Contest_466 #2025_09_07_Time_26_ms_(100.00%)_Space_84.36_MB_(100.00%)
-
-import kotlin.math.min
+// #Medium #Weekly_Contest_466 #2025_09_14_Time_3_ms_(100.00%)_Space_79.40_MB_(50.00%)
 
 class Solution {
     fun bowlSubarrays(nums: IntArray): Long {
-        val l = nums.size
-        var ans = 0
-        val stack: java.util.Deque<Int> = java.util.ArrayDeque<Int>()
-        for (i in 0..<l) {
-            while (stack.isNotEmpty() && nums[stack.peek()!!] < nums[i]) {
-                val mid: Int = stack.pop()!!
-                if (stack.isNotEmpty()) {
-                    val left: Int = stack.peek()!!
-                    if (min(nums[left], nums[i]) > nums[mid]) {
-                        ++ans
-                    }
-                }
+        val n = nums.size
+        var res = n
+        var pre = 0
+        for (a in nums) {
+            if (a > pre) {
+                res--
+                pre = a
+            }
+        }
+        pre = 0
+        for (i in n - 1 downTo 0) {
+            if (nums[i] > pre) {
+                res--
+                pre = nums[i]
             }
-            stack.push(i)
         }
-        return ans.toLong()
+        return res + 1L
     }
 }