Added tasks 3512-3519

Author: javadev

README.md

@@ -73,12 +73,12 @@ class Solution {
         var ans = maxHeights[pickId].toLong()
         var min = maxHeights[pickId].toLong()
         for (i in pickId - 1 downTo 0) {
-            min = min(min.toDouble(), maxHeights[i].toDouble()).toLong()
+            min = min(min, maxHeights[i].toLong())
             ans += min
         }
         min = maxHeights[pickId].toLong()
         for (i in pickId + 1 until maxHeights.size) {
-            min = min(min.toDouble(), maxHeights[i].toDouble()).toLong()
+            min = min(min, maxHeights[i].toLong())
             ans += min
         }
         return ans
@@ -93,7 +93,7 @@ class Solution {
                         maxHeights[i] >= maxHeights[i + 1]
                     )
             ) {
-                ans = max(ans.toDouble(), `fun`(maxHeights, i).toDouble()).toLong()
+                ans = max(ans, `fun`(maxHeights, i))
             }
         }
         return ans

src/main/kotlin/g2801_2900/s2865_beautiful_towers_i/readme.md

@@ -51,15 +51,15 @@ class Solution {
         var tempMax = nums[0]
         for (i in 1 until diff.size - 1) {
             diff[i] = tempMax - nums[i]
-            tempMax = max(tempMax.toDouble(), nums[i].toDouble()).toInt()
+            tempMax = max(tempMax, nums[i])
         }
         var max = Long.MIN_VALUE
         tempMax = nums[nums.size - 1]
         for (i in nums.size - 2 downTo 1) {
-            max = max(max.toDouble(), (tempMax.toLong() * diff[i]).toDouble()).toLong()
-            tempMax = max(tempMax.toDouble(), nums[i].toDouble()).toInt()
+            max = max(max, tempMax.toLong() * diff[i])
+            tempMax = max(tempMax, nums[i])
         }
-        return max(max.toDouble(), 0.0).toLong()
+        return max(max, 0)
     }
 }
 ```

src/main/kotlin/g2801_2900/s2874_maximum_value_of_an_ordered_triplet_ii/readme.md

@@ -68,14 +68,12 @@ class Solution {
         }
         val dp = IntArray(m)
         dp[0] = 0
-        dp[1] = min(x.toDouble(), (diffs[1] - diffs[0]).toDouble()).toInt()
+        dp[1] = min(x, diffs[1] - diffs[0])
         for (i in 2 until m) {
             if ((i and 1) == 1) {
-                dp[i] = min((dp[i - 1] + x).toDouble(), (dp[i - 2] + diffs[i] - diffs[i - 1]).toDouble())
-                    .toInt()
+                dp[i] = min(dp[i - 1] + x, dp[i - 2] + diffs[i] - diffs[i - 1])
             } else {
-                dp[i] = min(dp[i - 1].toDouble(), (dp[i - 2] + diffs[i] - diffs[i - 1]).toDouble())
-                    .toInt()
+                dp[i] = min(dp[i - 1], dp[i - 2] + diffs[i] - diffs[i - 1])
             }
         }
         return dp[m - 1]

src/main/kotlin/g2801_2900/s2896_apply_operations_to_make_two_strings_equal/readme.md

@@ -67,7 +67,7 @@ class Solution {
                 for (k in j + 1 until nums.size) {
                     if (nums[i] < nums[j] && nums[k] < nums[j]) {
                         val min = nums[i] + nums[k] + nums[j]
-                        output = min(min.toDouble(), output.toDouble()).toInt()
+                        output = min(min, output)
                     }
                 }
             }

src/main/kotlin/g2901_3000/s2908_minimum_sum_of_mountain_triplets_i/readme.md

@@ -84,8 +84,7 @@ class Solution {
         var ans = Int.MAX_VALUE
         for (i in 0 until n) {
             if (leftSmallest[i] != -1 && rightSmallest[i] != -1) {
-                ans = min(ans.toDouble(), (leftSmallest[i] + rightSmallest[i] + nums[i]).toDouble())
-                    .toInt()
+                ans = min(ans, leftSmallest[i] + rightSmallest[i] + nums[i])
             }
         }
         if (ans == Int.MAX_VALUE) {

src/main/kotlin/g2901_3000/s2909_minimum_sum_of_mountain_triplets_ii/readme.md

@@ -73,7 +73,7 @@ class Solution {
         }
         var min = INF
         for (j in (k - 1) * 2 until (i - 1)) {
-            min = min(min.toDouble(), (calc(j, k - 1) + change(j, i)).toDouble()).toInt()
+            min = min(min, calc(j, k - 1) + change(j, i))
         }
         dp[i][k] = min
         return min

src/main/kotlin/g2901_3000/s2911_minimum_changes_to_make_k_semi_palindromes/readme.md

@@ -130,7 +130,7 @@ class Solution {
             var index = index
             var result: Long = 0
             while (index > 0) {
-                result = max(tree[index].toDouble(), result.toDouble()).toLong()
+                result = max(tree[index], result)
                 index -= lowbit(index)
             }
             return result

src/main/kotlin/g2901_3000/s2926_maximum_balanced_subsequence_sum/readme.md

@@ -74,7 +74,7 @@ class Solution {
             if (acquired + 1 < n) {
                 var min = Int.MAX_VALUE
                 for (j in acquired + 1 downTo i + 1) {
-                    min = min(min.toDouble(), dp[j].toDouble()).toInt()
+                    min = min(min, dp[j])
                 }
                 dp[i] = prices[i] + min
             } else {

src/main/kotlin/g2901_3000/s2944_minimum_number_of_coins_for_fruits/readme.md

@@ -92,7 +92,7 @@ class Solution {
         var res: Long = 1
         for (i in 1 until sick.size) {
             val group = sick[i] - sick[i - 1] - 1
-            res = res * modPow(2, max(0.0, (group - 1).toDouble()).toInt(), MOD) % MOD
+            res = res * modPow(2, max(0, group - 1), MOD) % MOD
             res = res * binomCoeff(sick[i] - i, group) % MOD
         }
         return (res * binomCoeff(n - sick.size, n - sick[sick.size - 1] - 1) % MOD).toInt()