diff --git a/src/main/java/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/Solution.java b/src/main/java/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/Solution.java new file mode 100644 index 000000000..3e5d0bfd7 --- /dev/null +++ b/src/main/java/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/Solution.java @@ -0,0 +1,19 @@ +package g3101_3200.s3168_minimum_number_of_chairs_in_a_waiting_room; + +// #Easy #String #Simulation #2024_06_06_Time_1_ms_(100.00%)_Space_41.9_MB_(67.53%) + +public class Solution { + public int minimumChairs(String s) { + int count = 0; + int ans = Integer.MIN_VALUE; + for (char ch : s.toCharArray()) { + if (ch == 'E') { + count++; + ans = Math.max(ans, count); + } else { + count--; + } + } + return ans; + } +} diff --git a/src/main/java/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/readme.md b/src/main/java/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/java/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/java/g3101_3200/s3169_count_days_without_meetings/Solution.java b/src/main/java/g3101_3200/s3169_count_days_without_meetings/Solution.java new file mode 100644 index 000000000..79dff29fb --- /dev/null +++ b/src/main/java/g3101_3200/s3169_count_days_without_meetings/Solution.java @@ -0,0 +1,41 @@ +package g3101_3200.s3169_count_days_without_meetings; + +// #Medium #Array #Sorting #2024_06_06_Time_11_ms_(99.96%)_Space_113.7_MB_(5.10%) + +import java.util.ArrayList; +import java.util.List; + +public class Solution { + public int countDays(int days, int[][] meetings) { + List availableDays = new ArrayList<>(); + availableDays.add(new int[] {1, days}); + // Iterate through each meeting + for (int[] meeting : meetings) { + int start = meeting[0]; + int end = meeting[1]; + List newAvailableDays = new ArrayList<>(); + // Iterate through available days and split the intervals + for (int[] interval : 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(new int[] {interval[0], start - 1}); + } + if (interval[1] > end) { + newAvailableDays.add(new int[] {end + 1, interval[1]}); + } + } + } + availableDays = newAvailableDays; + } + // Count the remaining available days + int availableDaysCount = 0; + for (int[] interval : availableDays) { + availableDaysCount += interval[1] - interval[0] + 1; + } + return availableDaysCount; + } +} diff --git a/src/main/java/g3101_3200/s3169_count_days_without_meetings/readme.md b/src/main/java/g3101_3200/s3169_count_days_without_meetings/readme.md new file mode 100644 index 000000000..bc06872e1 --- /dev/null +++ b/src/main/java/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/java/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/Solution.java b/src/main/java/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/Solution.java new file mode 100644 index 000000000..8c820c926 --- /dev/null +++ b/src/main/java/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/Solution.java @@ -0,0 +1,38 @@ +package g3101_3200.s3170_lexicographically_minimum_string_after_removing_stars; + +// #Medium #String #Hash_Table #Greedy #Stack #Heap_Priority_Queue +// #2024_06_06_Time_29_ms_(99.93%)_Space_45.6_MB_(92.80%) + +import java.util.Arrays; + +public class Solution { + public String clearStars(String s) { + char[] arr = s.toCharArray(); + int[] idxChain = new int[arr.length]; + int[] lastIdx = new int[26]; + Arrays.fill(idxChain, -1); + Arrays.fill(lastIdx, -1); + for (int i = 0; i < arr.length; i++) { + if (arr[i] == '*') { + for (int j = 0; j < 26; j++) { + if (lastIdx[j] != -1) { + arr[lastIdx[j]] = '#'; + lastIdx[j] = idxChain[lastIdx[j]]; + break; + } + } + arr[i] = '#'; + } else { + idxChain[i] = lastIdx[arr[i] - 'a']; + lastIdx[arr[i] - 'a'] = i; + } + } + StringBuilder sb = new StringBuilder(); + for (char c : arr) { + if (c != '#') { + sb.append(c); + } + } + return sb.toString(); + } +} diff --git a/src/main/java/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/readme.md b/src/main/java/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/readme.md new file mode 100644 index 000000000..59cb849fc --- /dev/null +++ b/src/main/java/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/java/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/Solution.java b/src/main/java/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/Solution.java new file mode 100644 index 000000000..f1042608a --- /dev/null +++ b/src/main/java/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/Solution.java @@ -0,0 +1,18 @@ +package g3101_3200.s3171_find_subarray_with_bitwise_and_closest_to_k; + +// #Hard #Array #Binary_Search #Bit_Manipulation #Segment_Tree +// #2024_06_06_Time_10_ms_(98.04%)_Space_56.3_MB_(79.06%) + +public class Solution { + public int minimumDifference(int[] nums, int k) { + int res = Integer.MAX_VALUE; + for (int i = 0; i < nums.length; i++) { + res = Math.min(res, Math.abs(nums[i] - k)); + for (int j = i - 1; j >= 0 && (nums[j] & nums[i]) != nums[j]; j--) { + nums[j] &= nums[i]; + res = Math.min(res, Math.abs(nums[j] - k)); + } + } + return res; + } +} diff --git a/src/main/java/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/readme.md b/src/main/java/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/java/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/java/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/SolutionTest.java b/src/test/java/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/SolutionTest.java new file mode 100644 index 000000000..07ae85250 --- /dev/null +++ b/src/test/java/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/SolutionTest.java @@ -0,0 +1,23 @@ +package g3101_3200.s3168_minimum_number_of_chairs_in_a_waiting_room; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; + +import org.junit.jupiter.api.Test; + +class SolutionTest { + @Test + void minimumChairs() { + assertThat(new Solution().minimumChairs("EEEEEEE"), equalTo(7)); + } + + @Test + void minimumChairs2() { + assertThat(new Solution().minimumChairs("ELELEEL"), equalTo(2)); + } + + @Test + void minimumChairs3() { + assertThat(new Solution().minimumChairs("ELEELEELLL"), equalTo(3)); + } +} diff --git a/src/test/java/g3101_3200/s3169_count_days_without_meetings/SolutionTest.java b/src/test/java/g3101_3200/s3169_count_days_without_meetings/SolutionTest.java new file mode 100644 index 000000000..8ac7e5bc1 --- /dev/null +++ b/src/test/java/g3101_3200/s3169_count_days_without_meetings/SolutionTest.java @@ -0,0 +1,23 @@ +package g3101_3200.s3169_count_days_without_meetings; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; + +import org.junit.jupiter.api.Test; + +class SolutionTest { + @Test + void countDays() { + assertThat(new Solution().countDays(10, new int[][] {{5, 7}, {1, 3}, {9, 10}}), equalTo(2)); + } + + @Test + void countDays2() { + assertThat(new Solution().countDays(5, new int[][] {{2, 4}, {1, 3}}), equalTo(1)); + } + + @Test + void countDays3() { + assertThat(new Solution().countDays(6, new int[][] {{1, 6}}), equalTo(0)); + } +} diff --git a/src/test/java/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/SolutionTest.java b/src/test/java/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/SolutionTest.java new file mode 100644 index 000000000..0f250984b --- /dev/null +++ b/src/test/java/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/SolutionTest.java @@ -0,0 +1,18 @@ +package g3101_3200.s3170_lexicographically_minimum_string_after_removing_stars; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; + +import org.junit.jupiter.api.Test; + +class SolutionTest { + @Test + void clearStars() { + assertThat(new Solution().clearStars("aaba*"), equalTo("aab")); + } + + @Test + void clearStars2() { + assertThat(new Solution().clearStars("abc"), equalTo("abc")); + } +} diff --git a/src/test/java/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/SolutionTest.java b/src/test/java/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/SolutionTest.java new file mode 100644 index 000000000..9dbc1be22 --- /dev/null +++ b/src/test/java/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/SolutionTest.java @@ -0,0 +1,23 @@ +package g3101_3200.s3171_find_subarray_with_bitwise_and_closest_to_k; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; + +import org.junit.jupiter.api.Test; + +class SolutionTest { + @Test + void minimumDifference() { + assertThat(new Solution().minimumDifference(new int[] {1, 2, 4, 5}, 3), equalTo(1)); + } + + @Test + void minimumDifference2() { + assertThat(new Solution().minimumDifference(new int[] {1, 2, 1, 2}, 2), equalTo(0)); + } + + @Test + void minimumDifference3() { + assertThat(new Solution().minimumDifference(new int[] {1}, 10), equalTo(9)); + } +}