diff --git a/src/main/kotlin/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/Solution.kt b/src/main/kotlin/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/Solution.kt new file mode 100644 index 000000000..d5069ce2f --- /dev/null +++ b/src/main/kotlin/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/Solution.kt @@ -0,0 +1,21 @@ +package g3101_3200.s3168_minimum_number_of_chairs_in_a_waiting_room + +// #Easy #String #Simulation #2024_06_08_Time_148_ms_(86.52%)_Space_35_MB_(8.99%) + +import kotlin.math.max + +class Solution { + fun minimumChairs(s: String): Int { + var count = 0 + var ans = Int.MIN_VALUE + for (ch in s.toCharArray()) { + if (ch == 'E') { + count++ + ans = max(ans, count) + } else { + count-- + } + } + return ans + } +} diff --git a/src/main/kotlin/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/readme.md b/src/main/kotlin/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/readme.md new file mode 100644 index 000000000..164d83ac8 --- /dev/null +++ b/src/main/kotlin/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/readme.md @@ -0,0 +1,69 @@ +3168\. Minimum Number of Chairs in a Waiting Room + +Easy + +You are given a string `s`. Simulate events at each second `i`: + +* If `s[i] == 'E'`, a person enters the waiting room and takes one of the chairs in it. +* If `s[i] == 'L'`, a person leaves the waiting room, freeing up a chair. + +Return the **minimum** number of chairs needed so that a chair is available for every person who enters the waiting room given that it is initially **empty**. + +**Example 1:** + +**Input:** s = "EEEEEEE" + +**Output:** 7 + +**Explanation:** + +After each second, a person enters the waiting room and no person leaves it. Therefore, a minimum of 7 chairs is needed. + +**Example 2:** + +**Input:** s = "ELELEEL" + +**Output:** 2 + +**Explanation:** + +Let's consider that there are 2 chairs in the waiting room. The table below shows the state of the waiting room at each second. + +| Second | Event | People in the Waiting Room | Available Chairs | +|--------|-------|----------------------------|------------------| +| 0 | Enter | 1 | 1 | +| 1 | Leave | 0 | 2 | +| 2 | Enter | 1 | 1 | +| 3 | Leave | 0 | 2 | +| 4 | Enter | 1 | 1 | +| 5 | Enter | 2 | 0 | +| 6 | Leave | 1 | 1 | + +**Example 3:** + +**Input:** s = "ELEELEELLL" + +**Output:** 3 + +**Explanation:** + +Let's consider that there are 3 chairs in the waiting room. The table below shows the state of the waiting room at each second. + +| Second | Event | People in the Waiting Room | Available Chairs | +|--------|-------|----------------------------|------------------| +| 0 | Enter | 1 | 2 | +| 1 | Leave | 0 | 3 | +| 2 | Enter | 1 | 2 | +| 3 | Enter | 2 | 1 | +| 4 | Leave | 1 | 2 | +| 5 | Enter | 2 | 1 | +| 6 | Enter | 3 | 0 | +| 7 | Leave | 2 | 1 | +| 8 | Leave | 1 | 2 | +| 9 | Leave | 0 | 3 | + +**Constraints:** + +* `1 <= s.length <= 50` +* `s` consists only of the letters `'E'` and `'L'`. +* `s` represents a valid sequence of entries and exits. \ No newline at end of file diff --git a/src/main/kotlin/g3101_3200/s3169_count_days_without_meetings/Solution.kt b/src/main/kotlin/g3101_3200/s3169_count_days_without_meetings/Solution.kt new file mode 100644 index 000000000..99cce0d3e --- /dev/null +++ b/src/main/kotlin/g3101_3200/s3169_count_days_without_meetings/Solution.kt @@ -0,0 +1,38 @@ +package g3101_3200.s3169_count_days_without_meetings + +// #Medium #Array #Sorting #2024_06_08_Time_733_ms_(97.59%)_Space_101.5_MB_(93.98%) + +class Solution { + fun countDays(days: Int, meetings: Array): Int { + var availableDays: MutableList = ArrayList() + availableDays.add(intArrayOf(1, days)) + // Iterate through each meeting + for (meeting in meetings) { + val start = meeting[0] + val end = meeting[1] + val newAvailableDays: MutableList = ArrayList() + // Iterate through available days and split the intervals + for (interval in availableDays) { + if (start > interval[1] || end < interval[0]) { + // No overlap, keep the interval + newAvailableDays.add(interval) + } else { + // Overlap, split the interval + if (interval[0] < start) { + newAvailableDays.add(intArrayOf(interval[0], start - 1)) + } + if (interval[1] > end) { + newAvailableDays.add(intArrayOf(end + 1, interval[1])) + } + } + } + availableDays = newAvailableDays + } + // Count the remaining available days + var availableDaysCount = 0 + for (interval in availableDays) { + availableDaysCount += interval[1] - interval[0] + 1 + } + return availableDaysCount + } +} diff --git a/src/main/kotlin/g3101_3200/s3169_count_days_without_meetings/readme.md b/src/main/kotlin/g3101_3200/s3169_count_days_without_meetings/readme.md new file mode 100644 index 000000000..bc06872e1 --- /dev/null +++ b/src/main/kotlin/g3101_3200/s3169_count_days_without_meetings/readme.md @@ -0,0 +1,46 @@ +3169\. Count Days Without Meetings + +Medium + +You are given a positive integer `days` representing the total number of days an employee is available for work (starting from day 1). You are also given a 2D array `meetings` of size `n` where, `meetings[i] = [start_i, end_i]` represents the starting and ending days of meeting `i` (inclusive). + +Return the count of days when the employee is available for work but no meetings are scheduled. + +**Note:** The meetings may overlap. + +**Example 1:** + +**Input:** days = 10, meetings = [[5,7],[1,3],[9,10]] + +**Output:** 2 + +**Explanation:** + +There is no meeting scheduled on the 4th and 8th days. + +**Example 2:** + +**Input:** days = 5, meetings = [[2,4],[1,3]] + +**Output:** 1 + +**Explanation:** + +There is no meeting scheduled on the 5th day. + +**Example 3:** + +**Input:** days = 6, meetings = [[1,6]] + +**Output:** 0 + +**Explanation:** + +Meetings are scheduled for all working days. + +**Constraints:** + +* 1 <= days <= 109 +* 1 <= meetings.length <= 105 +* `meetings[i].length == 2` +* `1 <= meetings[i][0] <= meetings[i][1] <= days` \ No newline at end of file diff --git a/src/main/kotlin/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/Solution.kt b/src/main/kotlin/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/Solution.kt new file mode 100644 index 000000000..3c334252a --- /dev/null +++ b/src/main/kotlin/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/Solution.kt @@ -0,0 +1,36 @@ +package g3101_3200.s3170_lexicographically_minimum_string_after_removing_stars + +// #Medium #String #Hash_Table #Greedy #Stack #Heap_Priority_Queue +// #2024_06_08_Time_316_ms_(100.00%)_Space_40.9_MB_(89.58%) + +class Solution { + fun clearStars(s: String): String { + val arr = s.toCharArray() + val idxChain = IntArray(arr.size) + val lastIdx = IntArray(26) + idxChain.fill(-1) + lastIdx.fill(-1) + for (i in arr.indices) { + if (arr[i] == '*') { + for (j in 0..25) { + if (lastIdx[j] != -1) { + arr[lastIdx[j]] = '#' + lastIdx[j] = idxChain[lastIdx[j]] + break + } + } + arr[i] = '#' + } else { + idxChain[i] = lastIdx[arr[i].code - 'a'.code] + lastIdx[arr[i].code - 'a'.code] = i + } + } + val sb = StringBuilder() + for (c in arr) { + if (c != '#') { + sb.append(c) + } + } + return sb.toString() + } +} diff --git a/src/main/kotlin/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/readme.md b/src/main/kotlin/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/readme.md new file mode 100644 index 000000000..59cb849fc --- /dev/null +++ b/src/main/kotlin/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/readme.md @@ -0,0 +1,37 @@ +3170\. Lexicographically Minimum String After Removing Stars + +Medium + +You are given a string `s`. It may contain any number of `'*'` characters. Your task is to remove all `'*'` characters. + +While there is a `'*'`, do the following operation: + +* Delete the leftmost `'*'` and the **smallest** non-`'*'` character to its _left_. If there are several smallest characters, you can delete any of them. + +Return the lexicographically smallest resulting string after removing all `'*'` characters. + +**Example 1:** + +**Input:** s = "aaba\*" + +**Output:** "aab" + +**Explanation:** + +We should delete one of the `'a'` characters with `'*'`. If we choose `s[3]`, `s` becomes the lexicographically smallest. + +**Example 2:** + +**Input:** s = "abc" + +**Output:** "abc" + +**Explanation:** + +There is no `'*'` in the string. + +**Constraints:** + +* 1 <= s.length <= 105 +* `s` consists only of lowercase English letters and `'*'`. +* The input is generated such that it is possible to delete all `'*'` characters. \ No newline at end of file diff --git a/src/main/kotlin/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/Solution.kt b/src/main/kotlin/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/Solution.kt new file mode 100644 index 000000000..76a418334 --- /dev/null +++ b/src/main/kotlin/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/Solution.kt @@ -0,0 +1,23 @@ +package g3101_3200.s3171_find_subarray_with_bitwise_and_closest_to_k + +// #Hard #Array #Binary_Search #Bit_Manipulation #Segment_Tree +// #2024_06_08_Time_520_ms_(100.00%)_Space_63.6_MB_(96.15%) + +import kotlin.math.abs +import kotlin.math.min + +class Solution { + fun minimumDifference(nums: IntArray, k: Int): Int { + var res = Int.MAX_VALUE + for (i in nums.indices) { + res = min(res, abs((nums[i] - k))) + var j = i - 1 + while (j >= 0 && (nums[j] and nums[i]) != nums[j]) { + nums[j] = nums[j] and nums[i] + res = min(res, abs((nums[j] - k))) + j-- + } + } + return res + } +} diff --git a/src/main/kotlin/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/readme.md b/src/main/kotlin/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/readme.md new file mode 100644 index 000000000..8ee72a743 --- /dev/null +++ b/src/main/kotlin/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/readme.md @@ -0,0 +1,45 @@ +3171\. Find Subarray With Bitwise AND Closest to K + +Hard + +You are given an array `nums` and an integer `k`. You need to find a subarray of `nums` such that the **absolute difference** between `k` and the bitwise `AND` of the subarray elements is as **small** as possible. In other words, select a subarray `nums[l..r]` such that `|k - (nums[l] AND nums[l + 1] ... AND nums[r])|` is minimum. + +Return the **minimum** possible value of the absolute difference. + +A **subarray** is a contiguous **non-empty** sequence of elements within an array. + +**Example 1:** + +**Input:** nums = [1,2,4,5], k = 3 + +**Output:** 1 + +**Explanation:** + +The subarray `nums[2..3]` has `AND` value 4, which gives the minimum absolute difference `|3 - 4| = 1`. + +**Example 2:** + +**Input:** nums = [1,2,1,2], k = 2 + +**Output:** 0 + +**Explanation:** + +The subarray `nums[1..1]` has `AND` value 2, which gives the minimum absolute difference `|2 - 2| = 0`. + +**Example 3:** + +**Input:** nums = [1], k = 10 + +**Output:** 9 + +**Explanation:** + +There is a single subarray with `AND` value 1, which gives the minimum absolute difference `|10 - 1| = 9`. + +**Constraints:** + +* 1 <= nums.length <= 105 +* 1 <= nums[i] <= 109 +* 1 <= k <= 109 \ No newline at end of file diff --git a/src/test/kotlin/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/SolutionTest.kt b/src/test/kotlin/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/SolutionTest.kt new file mode 100644 index 000000000..130c881d5 --- /dev/null +++ b/src/test/kotlin/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/SolutionTest.kt @@ -0,0 +1,22 @@ +package g3101_3200.s3168_minimum_number_of_chairs_in_a_waiting_room + +import org.hamcrest.CoreMatchers.equalTo +import org.hamcrest.MatcherAssert.assertThat +import org.junit.jupiter.api.Test + +internal class SolutionTest { + @Test + fun minimumChairs() { + assertThat(Solution().minimumChairs("EEEEEEE"), equalTo(7)) + } + + @Test + fun minimumChairs2() { + assertThat(Solution().minimumChairs("ELELEEL"), equalTo(2)) + } + + @Test + fun minimumChairs3() { + assertThat(Solution().minimumChairs("ELEELEELLL"), equalTo(3)) + } +} diff --git a/src/test/kotlin/g3101_3200/s3169_count_days_without_meetings/SolutionTest.kt b/src/test/kotlin/g3101_3200/s3169_count_days_without_meetings/SolutionTest.kt new file mode 100644 index 000000000..16f6f2a8c --- /dev/null +++ b/src/test/kotlin/g3101_3200/s3169_count_days_without_meetings/SolutionTest.kt @@ -0,0 +1,31 @@ +package g3101_3200.s3169_count_days_without_meetings + +import org.hamcrest.CoreMatchers.equalTo +import org.hamcrest.MatcherAssert.assertThat +import org.junit.jupiter.api.Test + +internal class SolutionTest { + @Test + fun countDays() { + assertThat( + Solution().countDays( + 10, + arrayOf(intArrayOf(5, 7), intArrayOf(1, 3), intArrayOf(9, 10)) + ), + equalTo(2) + ) + } + + @Test + fun countDays2() { + assertThat( + Solution().countDays(5, arrayOf(intArrayOf(2, 4), intArrayOf(1, 3))), + equalTo(1) + ) + } + + @Test + fun countDays3() { + assertThat(Solution().countDays(6, arrayOf(intArrayOf(1, 6))), equalTo(0)) + } +} diff --git a/src/test/kotlin/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/SolutionTest.kt b/src/test/kotlin/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/SolutionTest.kt new file mode 100644 index 000000000..e605b2f92 --- /dev/null +++ b/src/test/kotlin/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/SolutionTest.kt @@ -0,0 +1,17 @@ +package g3101_3200.s3170_lexicographically_minimum_string_after_removing_stars + +import org.hamcrest.CoreMatchers.equalTo +import org.hamcrest.MatcherAssert.assertThat +import org.junit.jupiter.api.Test + +internal class SolutionTest { + @Test + fun clearStars() { + assertThat(Solution().clearStars("aaba*"), equalTo("aab")) + } + + @Test + fun clearStars2() { + assertThat(Solution().clearStars("abc"), equalTo("abc")) + } +} diff --git a/src/test/kotlin/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/SolutionTest.kt b/src/test/kotlin/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/SolutionTest.kt new file mode 100644 index 000000000..32c5eb9e4 --- /dev/null +++ b/src/test/kotlin/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/SolutionTest.kt @@ -0,0 +1,22 @@ +package g3101_3200.s3171_find_subarray_with_bitwise_and_closest_to_k + +import org.hamcrest.CoreMatchers.equalTo +import org.hamcrest.MatcherAssert.assertThat +import org.junit.jupiter.api.Test + +internal class SolutionTest { + @Test + fun minimumDifference() { + assertThat(Solution().minimumDifference(intArrayOf(1, 2, 4, 5), 3), equalTo(1)) + } + + @Test + fun minimumDifference2() { + assertThat(Solution().minimumDifference(intArrayOf(1, 2, 1, 2), 2), equalTo(0)) + } + + @Test + fun minimumDifference3() { + assertThat(Solution().minimumDifference(intArrayOf(1), 10), equalTo(9)) + } +}