Added tasks 1838-1850

Author: ThanhNIT

README.md

@@ -1071,6 +1071,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.13'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 1838 |[Frequency of the Most Frequent Element](src/main/kotlin/g1801_1900/s1838_frequency_of_the_most_frequent_element/Solution.kt)| Medium | Array, Sorting, Greedy, Binary_Search, Prefix_Sum, Sliding_Window | 564 | 88.89
 | 0540 |[Single Element in a Sorted Array](src.save/main/kotlin/g0501_0600/s0540_single_element_in_a_sorted_array/Solution.kt)| Medium | Array, Binary_Search | 274 | 86.67
 
 #### Day 10
@@ -1516,6 +1517,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.13'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 1845 |[Seat Reservation Manager](src/main/kotlin/g1801_1900/s1845_seat_reservation_manager/SeatManager.kt)| Medium | Design, Heap_Priority_Queue | 834 | 100.00
 | 0860 |[Lemonade Change](src.save/main/kotlin/g0801_0900/s0860_lemonade_change/Solution.kt)| Easy | Array, Greedy | 413 | 86.96
 
 #### Day 18
@@ -1914,6 +1916,16 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.13'
 | 1904 |[The Number of Full Rounds You Have Played](src/main/kotlin/g1901_2000/s1904_the_number_of_full_rounds_you_have_played/Solution.kt)| Medium | String, Math | 149 | 100.00
 | 1903 |[Largest Odd Number in String](src/main/kotlin/g1901_2000/s1903_largest_odd_number_in_string/Solution.kt)| Easy | String, Math, Greedy | 256 | 75.00
 | 1901 |[Find a Peak Element II](src/main/kotlin/g1901_2000/s1901_find_a_peak_element_ii/Solution.kt)| Medium | Array, Binary_Search, Matrix, Divide_and_Conquer, Binary_Search_II_Day_17 | 726 | 100.00
+| 1850 |[Minimum Adjacent Swaps to Reach the Kth Smallest Number](src/main/kotlin/g1801_1900/s1850_minimum_adjacent_swaps_to_reach_the_kth_smallest_number/Solution.kt)| Medium | String, Greedy, Two_Pointers | 193 | 100.00
+| 1849 |[Splitting a String Into Descending Consecutive Values](src/main/kotlin/g1801_1900/s1849_splitting_a_string_into_descending_consecutive_values/Solution.kt)| Medium | String, Backtracking | 136 | 100.00
+| 1848 |[Minimum Distance to the Target Element](src/main/kotlin/g1801_1900/s1848_minimum_distance_to_the_target_element/Solution.kt)| Easy | Array | 172 | 80.00
+| 1847 |[Closest Room](src/main/kotlin/g1801_1900/s1847_closest_room/Solution.kt)| Hard | Array, Sorting, Binary_Search | 1179 | 100.00
+| 1846 |[Maximum Element After Decreasing and Rearranging](src/main/kotlin/g1801_1900/s1846_maximum_element_after_decreasing_and_rearranging/Solution.kt)| Medium | Array, Sorting, Greedy | 412 | 100.00
+| 1845 |[Seat Reservation Manager](src/main/kotlin/g1801_1900/s1845_seat_reservation_manager/SeatManager.kt)| Medium | Design, Heap_Priority_Queue, Programming_Skills_II_Day_17 | 834 | 100.00
+| 1844 |[Replace All Digits with Characters](src/main/kotlin/g1801_1900/s1844_replace_all_digits_with_characters/Solution.kt)| Easy | String | 137 | 100.00
+| 1840 |[Maximum Building Height](src/main/kotlin/g1801_1900/s1840_maximum_building_height/Solution.kt)| Hard | Array, Math | 1210 | 100.00
+| 1839 |[Longest Substring Of All Vowels in Order](src/main/kotlin/g1801_1900/s1839_longest_substring_of_all_vowels_in_order/Solution.kt)| Medium | String, Sliding_Window | 290 | 80.00
+| 1838 |[Frequency of the Most Frequent Element](src/main/kotlin/g1801_1900/s1838_frequency_of_the_most_frequent_element/Solution.kt)| Medium | Array, Sorting, Greedy, Binary_Search, Prefix_Sum, Sliding_Window, Binary_Search_II_Day_9 | 564 | 88.89
 | 1837 |[Sum of Digits in Base K](src/main/kotlin/g1801_1900/s1837_sum_of_digits_in_base_k/Solution.kt)| Easy | Math | 120 | 100.00
 | 1835 |[Find XOR Sum of All Pairs Bitwise AND](src/main/kotlin/g1801_1900/s1835_find_xor_sum_of_all_pairs_bitwise_and/Solution.kt)| Hard | Array, Math, Bit_Manipulation | 604 | 100.00
 | 1834 |[Single-Threaded CPU](src/main/kotlin/g1801_1900/s1834_single_threaded_cpu/Solution.kt)| Medium | Array, Sorting, Heap_Priority_Queue | 1050 | 100.00

src/main/kotlin/g1801_1900/s1838_frequency_of_the_most_frequent_element/Solution.kt

@@ -0,0 +1,45 @@
+package g1801_1900.s1838_frequency_of_the_most_frequent_element
+
+// #Medium #Array #Sorting #Greedy #Binary_Search #Prefix_Sum #Sliding_Window
+// #Binary_Search_II_Day_9 #2023_06_22_Time_564_ms_(88.89%)_Space_50.8_MB_(100.00%)
+
+class Solution {
+    fun maxFrequency(nums: IntArray, k: Int): Int {
+        countingSort(nums)
+        var start = 0
+        var preSum = 0
+        var total = 1
+        for (i in nums.indices) {
+            var length = i - start + 1
+            var product = nums[i] * length
+            preSum += nums[i]
+            while (product - preSum > k) {
+                preSum -= nums[start++]
+                length--
+                product = nums[i] * length
+            }
+            total = total.coerceAtLeast(length)
+        }
+        return total
+    }
+
+    private fun countingSort(nums: IntArray) {
+        var max = Int.MIN_VALUE
+        for (num in nums) {
+            max = max.coerceAtLeast(num)
+        }
+        val map = IntArray(max + 1)
+        for (num in nums) {
+            map[num]++
+        }
+        var i = 0
+        var j = 0
+        while (i <= max) {
+            if (map[i]-- > 0) {
+                nums[j++] = i
+            } else {
+                i++
+            }
+        }
+    }
+}

src/main/kotlin/g1801_1900/s1838_frequency_of_the_most_frequent_element/readme.md

@@ -0,0 +1,43 @@
+1838\. Frequency of the Most Frequent Element
+
+Medium
+
+The **frequency** of an element is the number of times it occurs in an array.
+
+You are given an integer array `nums` and an integer `k`. In one operation, you can choose an index of `nums` and increment the element at that index by `1`.
+
+Return _the **maximum possible frequency** of an element after performing **at most**_ `k` _operations_.
+
+**Example 1:**
+
+**Input:** nums = [1,2,4], k = 5
+
+**Output:** 3
+
+**Explanation:** Increment the first element three times and the second element two times to make nums = [4,4,4]. 4 has a frequency of 3.
+
+**Example 2:**
+
+**Input:** nums = [1,4,8,13], k = 5
+
+**Output:** 2
+
+**Explanation:** There are multiple optimal solutions: 
+
+- Increment the first element three times to make nums = [4,4,8,13]. 4 has a frequency of 2.
+
+- Increment the second element four times to make nums = [1,8,8,13]. 8 has a frequency of 2. 
+
+- Increment the third element five times to make nums = [1,4,13,13]. 13 has a frequency of 2.
+
+**Example 3:**
+
+**Input:** nums = [3,9,6], k = 2
+
+**Output:** 1
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>
+*   <code>1 <= k <= 10<sup>5</sup></code>

src/main/kotlin/g1801_1900/s1839_longest_substring_of_all_vowels_in_order/Solution.kt

@@ -0,0 +1,26 @@
+package g1801_1900.s1839_longest_substring_of_all_vowels_in_order
+
+// #Medium #String #Sliding_Window #2023_06_22_Time_290_ms_(80.00%)_Space_48.7_MB_(80.00%)
+
+class Solution {
+    fun longestBeautifulSubstring(word: String): Int {
+        var cnt = 1
+        var len = 1
+        var maxLen = 0
+        for (i in 1 until word.length) {
+            if (word[i - 1] == word[i]) {
+                ++len
+            } else if (word[i - 1] < word[i]) {
+                ++len
+                ++cnt
+            } else {
+                cnt = 1
+                len = 1
+            }
+            if (cnt == 5) {
+                maxLen = maxLen.coerceAtLeast(len)
+            }
+        }
+        return maxLen
+    }
+}

src/main/kotlin/g1801_1900/s1839_longest_substring_of_all_vowels_in_order/readme.md

@@ -0,0 +1,43 @@
+1839\. Longest Substring Of All Vowels in Order
+
+Medium
+
+A string is considered **beautiful** if it satisfies the following conditions:
+
+*   Each of the 5 English vowels (`'a'`, `'e'`, `'i'`, `'o'`, `'u'`) must appear **at least once** in it.
+*   The letters must be sorted in **alphabetical order** (i.e. all `'a'`s before `'e'`s, all `'e'`s before `'i'`s, etc.).
+
+For example, strings `"aeiou"` and `"aaaaaaeiiiioou"` are considered **beautiful**, but `"uaeio"`, `"aeoiu"`, and `"aaaeeeooo"` are **not beautiful**.
+
+Given a string `word` consisting of English vowels, return _the **length of the longest beautiful substring** of_ `word`_. If no such substring exists, return_ `0`.
+
+A **substring** is a contiguous sequence of characters in a string.
+
+**Example 1:**
+
+**Input:** word = "aeiaaioaaaaeiiiiouuuooaauuaeiu"
+
+**Output:** 13
+
+**Explanation:** The longest beautiful substring in word is "aaaaeiiiiouuu" of length 13.
+
+**Example 2:**
+
+**Input:** word = "aeeeiiiioooauuuaeiou"
+
+**Output:** 5
+
+**Explanation:** The longest beautiful substring in word is "aeiou" of length 5.
+
+**Example 3:**
+
+**Input:** word = "a"
+
+**Output:** 0
+
+**Explanation:** There is no beautiful substring, so return 0.
+
+**Constraints:**
+
+*   <code>1 <= word.length <= 5 * 10<sup>5</sup></code>
+*   `word` consists of characters `'a'`, `'e'`, `'i'`, `'o'`, and `'u'`.

src/main/kotlin/g1801_1900/s1840_maximum_building_height/Solution.kt

@@ -0,0 +1,36 @@
+package g1801_1900.s1840_maximum_building_height
+
+// #Hard #Array #Math #2023_06_22_Time_1210_ms_(100.00%)_Space_118.6_MB_(100.00%)
+
+class Solution {
+    fun maxBuilding(n: Int, restrictions: Array<IntArray>): Int {
+        if (restrictions.isEmpty()) {
+            return n - 1
+        }
+        val m = restrictions.size
+        restrictions.sortWith(compareBy { a: IntArray -> a[0] })
+        for (i in m - 2 downTo 0) {
+            restrictions[i][1] =
+                restrictions[i][1].coerceAtMost(restrictions[i + 1][1] + restrictions[i + 1][0] - restrictions[i][0])
+        }
+        var id = 1
+        var height = 0
+        var res = 0
+        for (r in restrictions) {
+            var currMax: Int
+            if (r[1] >= height + r[0] - id) {
+                currMax = height + r[0] - id
+                height = currMax
+            } else {
+                currMax = (height + r[0] - id + r[1]) / 2
+                height = r[1]
+            }
+            id = r[0]
+            res = res.coerceAtLeast(currMax)
+        }
+        if (id != n) {
+            res = res.coerceAtLeast(height + n - id)
+        }
+        return res
+    }
+}

src/main/kotlin/g1801_1900/s1840_maximum_building_height/readme.md

@@ -0,0 +1,55 @@
+1840\. Maximum Building Height
+
+Hard
+
+You want to build `n` new buildings in a city. The new buildings will be built in a line and are labeled from `1` to `n`.
+
+However, there are city restrictions on the heights of the new buildings:
+
+*   The height of each building must be a non-negative integer.
+*   The height of the first building **must** be `0`.
+*   The height difference between any two adjacent buildings **cannot exceed** `1`.
+
+Additionally, there are city restrictions on the maximum height of specific buildings. These restrictions are given as a 2D integer array `restrictions` where <code>restrictions[i] = [id<sub>i</sub>, maxHeight<sub>i</sub>]</code> indicates that building <code>id<sub>i</sub></code> must have a height **less than or equal to** <code>maxHeight<sub>i</sub></code>.
+
+It is guaranteed that each building will appear **at most once** in `restrictions`, and building `1` will **not** be in `restrictions`.
+
+Return _the **maximum possible height** of the **tallest** building_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/08/ic236-q4-ex1-1.png)
+
+**Input:** n = 5, restrictions = [[2,1],[4,1]]
+
+**Output:** 2
+
+**Explanation:** The green area in the image indicates the maximum allowed height for each building. We can build the buildings with heights [0,1,2,1,2], and the tallest building has a height of 2.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/04/08/ic236-q4-ex2.png)
+
+**Input:** n = 6, restrictions = []
+
+**Output:** 5
+
+**Explanation:** The green area in the image indicates the maximum allowed height for each building. We can build the buildings with heights [0,1,2,3,4,5], and the tallest building has a height of 5.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/04/08/ic236-q4-ex3.png)
+
+**Input:** n = 10, restrictions = [[5,3],[2,5],[7,4],[10,3]]
+
+**Output:** 5
+
+**Explanation:** The green area in the image indicates the maximum allowed height for each building. We can build the buildings with heights [0,1,2,3,3,4,4,5,4,3], and the tallest building has a height of 5.
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>9</sup></code>
+*   <code>0 <= restrictions.length <= min(n - 1, 10<sup>5</sup>)</code>
+*   <code>2 <= id<sub>i</sub> <= n</code>
+*   <code>id<sub>i</sub></code> is **unique**.
+*   <code>0 <= maxHeight<sub>i</sub> <= 10<sup>9</sup></code>

src/main/kotlin/g1801_1900/s1844_replace_all_digits_with_characters/Solution.kt

@@ -0,0 +1,17 @@
+package g1801_1900.s1844_replace_all_digits_with_characters
+
+// #Easy #String #2023_06_22_Time_137_ms_(100.00%)_Space_34.1_MB_(100.00%)
+
+class Solution {
+    fun replaceDigits(s: String): String {
+        val sb = StringBuilder()
+        for (c in s.toCharArray()) {
+            if (Character.isAlphabetic(c.code)) {
+                sb.append(c)
+            } else {
+                sb.append((sb[sb.length - 1].code + Character.getNumericValue(c)).toChar())
+            }
+        }
+        return sb.toString()
+    }
+}

src/main/kotlin/g1801_1900/s1844_replace_all_digits_with_characters/readme.md

@@ -0,0 +1,49 @@
+1844\. Replace All Digits with Characters
+
+Easy
+
+You are given a **0-indexed** string `s` that has lowercase English letters in its **even** indices and digits in its **odd** indices.
+
+There is a function `shift(c, x)`, where `c` is a character and `x` is a digit, that returns the <code>x<sup>th</sup></code> character after `c`.
+
+*   For example, `shift('a', 5) = 'f'` and `shift('x', 0) = 'x'`.
+
+For every **odd** index `i`, you want to replace the digit `s[i]` with `shift(s[i-1], s[i])`.
+
+Return `s` _after replacing all digits. It is **guaranteed** that_ `shift(s[i-1], s[i])` _will never exceed_ `'z'`.
+
+**Example 1:**
+
+**Input:** s = "a1c1e1"
+
+**Output:** "abcdef"
+
+**Explanation:** The digits are replaced as follows: 
+
+- s[1] -> shift('a',1) = 'b' 
+
+- s[3] -> shift('c',1) = 'd' 
+
+- s[5] -> shift('e',1) = 'f'
+
+**Example 2:**
+
+**Input:** s = "a1b2c3d4e"
+
+**Output:** "abbdcfdhe"
+
+**Explanation:** The digits are replaced as follows: 
+
+- s[1] -> shift('a',1) = 'b' 
+
+- s[3] -> shift('b',2) = 'd' 
+
+- s[5] -> shift('c',3) = 'f' 
+
+- s[7] -> shift('d',4) = 'h'
+
+**Constraints:**
+
+*   `1 <= s.length <= 100`
+*   `s` consists only of lowercase English letters and digits.
+*   `shift(s[i-1], s[i]) <= 'z'` for all **odd** indices `i`.

src/main/kotlin/g1801_1900/s1845_seat_reservation_manager/SeatManager.kt

@@ -0,0 +1,25 @@
+package g1801_1900.s1845_seat_reservation_manager
+
+// #Medium #Design #Heap_Priority_Queue #Programming_Skills_II_Day_17
+// #2023_06_22_Time_834_ms_(100.00%)_Space_94.6_MB_(91.67%)
+
+import java.util.PriorityQueue
+import java.util.Queue
+
+class SeatManager(n: Int) {
+    private val seats: Queue<Int>
+    private var smallest: Int
+
+    init {
+        seats = PriorityQueue()
+        smallest = 0
+    }
+
+    fun reserve(): Int {
+        return if (seats.isEmpty()) ++smallest else seats.poll()
+    }
+
+    fun unreserve(seatNumber: Int) {
+        seats.offer(seatNumber)
+    }
+}