Added tasks 3168-3178

Author: javadev

README.md

@@ -1816,6 +1816,15 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3178 |[Find the Child Who Has the Ball After K Seconds](src/main/java/g3101_3200/s3178_find_the_child_who_has_the_ball_after_k_seconds)| Easy | Math, Simulation | 0 | 100.00
+| 3177 |[Find the Maximum Length of a Good Subsequence II](src/main/java/g3101_3200/s3177_find_the_maximum_length_of_a_good_subsequence_ii)| Hard | Array, Hash_Table, Dynamic_Programming | 11 | 100.00
+| 3176 |[Find the Maximum Length of a Good Subsequence I](src/main/java/g3101_3200/s3176_find_the_maximum_length_of_a_good_subsequence_i)| Medium | Array, Hash_Table, Dynamic_Programming | 4 | 99.70
+| 3175 |[Find The First Player to win K Games in a Row](src/main/java/g3101_3200/s3175_find_the_first_player_to_win_k_games_in_a_row)| Medium | Array, Simulation | 1 | 100.00
+| 3174 |[Clear Digits](src/main/java/g3101_3200/s3174_clear_digits)| Easy | String, Hash_Table, Simulation | 1 | 100.00
+| 3171 |[Find Subarray With Bitwise AND Closest to K](src/main/java/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k)| Hard | Array, Binary_Search, Bit_Manipulation, Segment_Tree | 10 | 98.04
+| 3170 |[Lexicographically Minimum String After Removing Stars](src/main/java/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars)| Medium | String, Hash_Table, Greedy, Stack, Heap_Priority_Queue | 29 | 99.93
+| 3169 |[Count Days Without Meetings](src/main/java/g3101_3200/s3169_count_days_without_meetings)| Medium | Array, Sorting | 11 | 99.96
+| 3168 |[Minimum Number of Chairs in a Waiting Room](src/main/java/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room)| Easy | String, Simulation | 1 | 100.00
 | 3165 |[Maximum Sum of Subsequence With Non-adjacent Elements](src/main/java/g3101_3200/s3165_maximum_sum_of_subsequence_with_non_adjacent_elements)| Hard | Array, Dynamic_Programming, Divide_and_Conquer, Segment_Tree | 1927 | 87.75
 | 3164 |[Find the Number of Good Pairs II](src/main/java/g3101_3200/s3164_find_the_number_of_good_pairs_ii)| Medium | Array, Hash_Table | 407 | 75.28
 | 3163 |[String Compression III](src/main/java/g3101_3200/s3163_string_compression_iii)| Medium | String | 17 | 88.10

src/main/java/g0201_0300/s0208_implement_trie_prefix_tree/readme.md

@@ -102,6 +102,14 @@ public class Trie {
         return startWith;
     }
 }
+
+/*
+ * Your Trie object will be instantiated and called as such:
+ * Trie obj = new Trie();
+ * obj.insert(word);
+ * boolean param_2 = obj.search(word);
+ * boolean param_3 = obj.startsWith(prefix);
+ */
 ```
 
 **Time Complexity (Big O Time):**

src/main/java/g2801_2900/s2836_maximize_value_of_function_in_a_ball_passing_game/readme.md

@@ -105,4 +105,4 @@ public class Solution {
         return ans;
     }
 }
-```
+```

src/main/java/g3101_3200/s3168_minimum_number_of_chairs_in_a_waiting_room/readme.md

@@ -0,0 +1,92 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 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.
+
+## Solution
+
+```java
+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;
+    }
+}
+```

src/main/java/g3101_3200/s3169_count_days_without_meetings/readme.md

@@ -0,0 +1,91 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 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 4<sup>th</sup> and 8<sup>th</sup> days.
+
+**Example 2:**
+
+**Input:** days = 5, meetings = \[\[2,4],[1,3]]
+
+**Output:** 1
+
+**Explanation:**
+
+There is no meeting scheduled on the 5<sup>th</sup> day.
+
+**Example 3:**
+
+**Input:** days = 6, meetings = \[\[1,6]]
+
+**Output:** 0
+
+**Explanation:**
+
+Meetings are scheduled for all working days.
+
+**Constraints:**
+
+*   <code>1 <= days <= 10<sup>9</sup></code>
+*   <code>1 <= meetings.length <= 10<sup>5</sup></code>
+*   `meetings[i].length == 2`
+*   `1 <= meetings[i][0] <= meetings[i][1] <= days`
+
+## Solution
+
+```java
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public int countDays(int days, int[][] meetings) {
+        List<int[]> 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<int[]> 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;
+    }
+}
+```

src/main/java/g3101_3200/s3170_lexicographically_minimum_string_after_removing_stars/readme.md

@@ -0,0 +1,78 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 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:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists only of lowercase English letters and `'*'`.
+*   The input is generated such that it is possible to delete all `'*'` characters.
+
+## Solution
+
+```java
+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();
+    }
+}
+```

src/main/java/g3101_3200/s3171_find_subarray_with_bitwise_and_closest_to_k/readme.md

@@ -0,0 +1,66 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 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:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>
+*   <code>1 <= k <= 10<sup>9</sup></code>
+
+## Solution
+
+```java
+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;
+    }
+}
+```