Added tasks 2785-2789

Author: javadev

src/main/kotlin/g2701_2800/s2785_sort_vowels_in_a_string/Solution.kt

@@ -0,0 +1,30 @@
+package g2701_2800.s2785_sort_vowels_in_a_string
+
+// #Medium #String #Sorting #2023_08_08_Time_233_ms_(100.00%)_Space_38.6_MB_(100.00%)
+
+class Solution {
+    fun sortVowels(s: String): String {
+        val vowelCount = IntArray(11)
+        val countIndexMap = IntArray(128)
+        val result = s.toCharArray()
+        val charMap = "AEIOUaeiou".toCharArray()
+        run {
+            var i = 0
+            while (i < charMap.size) {
+                countIndexMap[charMap[i].code] = ++i
+            }
+        }
+        for (c in result) vowelCount[countIndexMap[c.code]]++
+        var j = 1
+        var i = 0
+        while (j < vowelCount.size) {
+            if (vowelCount[j] > 0) while (i < result.size) {
+                if (countIndexMap[result[i++].code] == 0) continue
+                vowelCount[j]--
+                result[i - 1] = charMap[j - 1]
+                break
+            } else j++
+        }
+        return String(result)
+    }
+}

src/main/kotlin/g2701_2800/s2785_sort_vowels_in_a_string/readme.md

@@ -0,0 +1,33 @@
+2785\. Sort Vowels in a String
+
+Medium
+
+Given a **0-indexed** string `s`, **permute** `s` to get a new string `t` such that:
+
+*   All consonants remain in their original places. More formally, if there is an index `i` with `0 <= i < s.length` such that `s[i]` is a consonant, then `t[i] = s[i]`.
+*   The vowels must be sorted in the **nondecreasing** order of their **ASCII** values. More formally, for pairs of indices `i`, `j` with `0 <= i < j < s.length` such that `s[i]` and `s[j]` are vowels, then `t[i]` must not have a higher ASCII value than `t[j]`.
+
+Return _the resulting string_.
+
+The vowels are `'a'`, `'e'`, `'i'`, `'o'`, and `'u'`, and they can appear in lowercase or uppercase. Consonants comprise all letters that are not vowels.
+
+**Example 1:**
+
+**Input:** s = "lEetcOde"
+
+**Output:** "lEOtcede"
+
+**Explanation:** 'E', 'O', and 'e' are the vowels in s; 'l', 't', 'c', and 'd' are all consonants. The vowels are sorted according to their ASCII values, and the consonants remain in the same places. 
+
+**Example 2:**
+
+**Input:** s = "lYmpH"
+
+**Output:** "lYmpH"
+
+**Explanation:** There are no vowels in s (all characters in s are consonants), so we return "lYmpH". 
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists only of letters of the English alphabet in **uppercase and lowercase**.

src/main/kotlin/g2701_2800/s2786_visit_array_positions_to_maximize_score/Solution.kt

@@ -0,0 +1,18 @@
+package g2701_2800.s2786_visit_array_positions_to_maximize_score
+
+// #Medium #Array #Dynamic_Programming #2023_08_08_Time_625_ms_(84.00%)_Space_68.5_MB_(52.00%)
+
+import kotlin.math.max
+
+class Solution {
+    fun maxScore(nums: IntArray, x: Int): Long {
+        val dp = longArrayOf(-x.toLong(), -x.toLong())
+        dp[nums[0] and 1] = nums[0].toLong()
+        for (i in 1 until nums.size) {
+            val toggle = dp[nums[i] and 1 xor 1] - x
+            val nottoggle = dp[nums[i] and 1]
+            dp[nums[i] and 1] = (max(toggle.toDouble(), nottoggle.toDouble()) + nums[i]).toLong()
+        }
+        return max(dp[0].toDouble(), dp[1].toDouble()).toLong()
+    }
+}

src/main/kotlin/g2701_2800/s2786_visit_array_positions_to_maximize_score/readme.md

@@ -0,0 +1,46 @@
+2786\. Visit Array Positions to Maximize Score
+
+Medium
+
+You are given a **0-indexed** integer array `nums` and a positive integer `x`.
+
+You are **initially** at position `0` in the array and you can visit other positions according to the following rules:
+
+*   If you are currently in position `i`, then you can move to **any** position `j` such that `i < j`.
+*   For each position `i` that you visit, you get a score of `nums[i]`.
+*   If you move from a position `i` to a position `j` and the **parities** of `nums[i]` and `nums[j]` differ, then you lose a score of `x`.
+
+Return _the **maximum** total score you can get_.
+
+**Note** that initially you have `nums[0]` points.
+
+**Example 1:**
+
+**Input:** nums = [2,3,6,1,9,2], x = 5
+
+**Output:** 13
+
+**Explanation:**
+
+We can visit the following positions in the array: 0 -> 2 -> 3 -> 4.
+
+The corresponding values are 2, 6, 1 and 9. Since the integers 6 and 1 have different parities, the move 2 -> 3 will make you lose a score of x = 5.
+
+The total score will be: 2 + 6 + 1 + 9 - 5 = 13. 
+
+**Example 2:**
+
+**Input:** nums = [2,4,6,8], x = 3
+
+**Output:** 20
+
+**Explanation:**
+
+All the integers in the array have the same parities, so we can visit all of them without losing any score.
+
+The total score is: 2 + 4 + 6 + 8 = 20. 
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i], x <= 10<sup>6</sup></code>

src/main/kotlin/g2701_2800/s2787_ways_to_express_an_integer_as_sum_of_powers/Solution.kt

@@ -0,0 +1,20 @@
+package g2701_2800.s2787_ways_to_express_an_integer_as_sum_of_powers
+
+// #Medium #Dynamic_Programming #2023_08_08_Time_152_ms_(100.00%)_Space_35.8_MB_(90.91%)
+
+class Solution {
+    fun numberOfWays(n: Int, x: Int): Int {
+        val dp = IntArray(301)
+        val mod = 1000000007
+        var v: Int
+        dp[0] = 1
+        var a = 1
+        while ((Math.pow(a.toDouble(), x.toDouble())).also { v = it.toInt() } <= n) {
+            for (i in n downTo v) {
+                dp[i] = (dp[i] + dp[i - v]) % mod
+            }
+            a++
+        }
+        return dp[n]
+    }
+}

src/main/kotlin/g2701_2800/s2787_ways_to_express_an_integer_as_sum_of_powers/readme.md

@@ -0,0 +1,42 @@
+2787\. Ways to Express an Integer as Sum of Powers
+
+Medium
+
+Given two **positive** integers `n` and `x`.
+
+Return _the number of ways_ `n` _can be expressed as the sum of the_ <code>x<sup>th</sup></code> _power of **unique** positive integers, in other words, the number of sets of unique integers_ <code>[n<sub>1</sub>, n<sub>2</sub>, ..., n<sub>k</sub>]</code> _where_ <code>n = n<sub>1</sub><sup>x</sup> + n<sub>2</sub><sup>x</sup> + ... + n<sub>k</sub><sup>x</sup></code>_._
+
+Since the result can be very large, return it modulo <code>10<sup>9</sup> + 7</code>.
+
+For example, if `n = 160` and `x = 3`, one way to express `n` is <code>n = 2<sup>3</sup> + 3<sup>3</sup> + 5<sup>3</sup></code>.
+
+**Example 1:**
+
+**Input:** n = 10, x = 2
+
+**Output:** 1
+
+**Explanation:**
+
+We can express n as the following: n = 3<sup>2</sup> + 1<sup>2</sup> = 10.
+
+It can be shown that it is the only way to express 10 as the sum of the 2<sup>nd</sup> power of unique integers. 
+
+**Example 2:**
+
+**Input:** n = 4, x = 1
+
+**Output:** 2
+
+**Explanation:**
+
+We can express n in the following ways:
+
+- n = 4<sup>1</sup> = 4.
+
+- n = 3<sup>1</sup> + 1<sup>1</sup> = 4. 
+
+**Constraints:**
+
+*   `1 <= n <= 300`
+*   `1 <= x <= 5`

src/main/kotlin/g2701_2800/s2788_split_strings_by_separator/Solution.kt

@@ -0,0 +1,24 @@
+package g2701_2800.s2788_split_strings_by_separator
+
+// #Easy #Array #String #2023_08_08_Time_314_ms_(85.45%)_Space_38_MB_(98.18%)
+
+class Solution {
+    fun splitWordsBySeparator(words: List<String>, separator: Char): List<String> {
+        val list: MutableList<String> = ArrayList()
+        for (str in words) {
+            var si = 0
+            for (i in str.indices) {
+                if (str[i] == separator) {
+                    if (i > si) {
+                        list.add(str.substring(si, i))
+                    }
+                    si = i + 1
+                }
+            }
+            if (si != str.length) {
+                list.add(str.substring(si, str.length))
+            }
+        }
+        return list
+    }
+}

src/main/kotlin/g2701_2800/s2788_split_strings_by_separator/readme.md

@@ -0,0 +1,62 @@
+2788\. Split Strings by Separator
+
+Easy
+
+Given an array of strings `words` and a character `separator`, **split** each string in `words` by `separator`.
+
+Return _an array of strings containing the new strings formed after the splits, **excluding empty strings**._
+
+**Notes**
+
+*   `separator` is used to determine where the split should occur, but it is not included as part of the resulting strings.
+*   A split may result in more than two strings.
+*   The resulting strings must maintain the same order as they were initially given.
+
+**Example 1:**
+
+**Input:** words = ["one.two.three","four.five","six"], separator = "."
+
+**Output:** ["one","two","three","four","five","six"]
+
+**Explanation:**
+
+In this example we split as follows: "one.two.three" splits into
+
+"one", "two", "three" "four.five" splits into
+
+"four", "five" "six" splits into "six"
+
+Hence, the resulting array is ["one","two","three","four","five","six"].
+
+**Example 2:**
+
+**Input:** words = ["$easy$","$problem$"], separator = "$"
+
+**Output:** ["easy","problem"]
+
+**Explanation:**
+
+In this example we split as follows:
+
+"$easy$" splits into "easy" (excluding empty strings)
+
+"$problem$" splits into "problem" (excluding empty strings)
+
+Hence, the resulting array is ["easy","problem"]. 
+
+**Example 3:**
+
+**Input:** words = ["|||"], separator = "|"
+
+**Output:** []
+
+**Explanation:**
+
+In this example the resulting split of "|||" will contain only empty strings, so we return an empty array []. 
+
+**Constraints:**
+
+*   `1 <= words.length <= 100`
+*   `1 <= words[i].length <= 20`
+*   characters in `words[i]` are either lowercase English letters or characters from the string `".,|$#@"` (excluding the quotes)
+*   `separator` is a character from the string `".,|$#@"` (excluding the quotes)

src/main/kotlin/g2701_2800/s2789_largest_element_in_an_array_after_merge_operations/Solution.kt

@@ -0,0 +1,17 @@
+package g2701_2800.s2789_largest_element_in_an_array_after_merge_operations
+
+// #Medium #Array #Greedy #Prefix_Sum #2023_08_08_Time_683_ms_(73.68%)_Space_70.8_MB_(42.10%)
+
+class Solution {
+    fun maxArrayValue(nums: IntArray): Long {
+        var ans = nums[nums.size - 1].toLong()
+        for (i in nums.size - 1 downTo 1) {
+            if (ans >= nums[i - 1]) {
+                ans += nums[i - 1].toLong()
+            } else {
+                ans = nums[i - 1].toLong()
+            }
+        }
+        return ans
+    }
+}

src/main/kotlin/g2701_2800/s2789_largest_element_in_an_array_after_merge_operations/readme.md

@@ -0,0 +1,50 @@
+2789\. Largest Element in an Array after Merge Operations
+
+Medium
+
+You are given a **0-indexed** array `nums` consisting of positive integers.
+
+You can do the following operation on the array **any** number of times:
+
+*   Choose an integer `i` such that `0 <= i < nums.length - 1` and `nums[i] <= nums[i + 1]`. Replace the element `nums[i + 1]` with `nums[i] + nums[i + 1]` and delete the element `nums[i]` from the array.
+
+Return _the value of the **largest** element that you can possibly obtain in the final array._
+
+**Example 1:**
+
+**Input:** nums = [2,3,7,9,3]
+
+**Output:** 21
+
+**Explanation:**
+
+We can apply the following operations on the array:
+
+- Choose i = 0. The resulting array will be nums = [<ins>5</ins>,7,9,3].
+
+- Choose i = 1. The resulting array will be nums = [5,<ins>16</ins>,3].
+
+- Choose i = 0. The resulting array will be nums = [<ins>21</ins>,3].
+
+The largest element in the final array is 21. It can be shown that we cannot obtain a larger element. 
+
+**Example 2:**
+
+**Input:** nums = [5,3,3]
+
+**Output:** 11
+
+**Explanation:**
+
+We can do the following operations on the array:
+
+- Choose i = 1. The resulting array will be nums = [5,<ins>6</ins>].
+
+- Choose i = 0. The resulting array will be nums = [<ins>11</ins>].
+
+There is only one element in the final array, which is 11. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>6</sup></code>