Added tasks 2942, 2943, 2944

Author: javadev

src/main/java/g2901_3000/s2942_find_words_containing_character/Solution.java

@@ -0,0 +1,21 @@
+package g2901_3000.s2942_find_words_containing_character;
+
+// #Easy #Array #String #2024_01_04_Time_2_ms_(72.65%)_Space_44.8_MB_(14.23%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public List<Integer> findWordsContaining(String[] words, char x) {
+        List<Integer> ans = new ArrayList<>();
+        for (int i = 0; i < words.length; i++) {
+            for (int j = 0; j < words[i].length(); j++) {
+                if (words[i].charAt(j) == x) {
+                    ans.add(i);
+                    break;
+                }
+            }
+        }
+        return ans;
+    }
+}

src/main/java/g2901_3000/s2942_find_words_containing_character/readme.md

@@ -0,0 +1,40 @@
+2942\. Find Words Containing Character
+
+Easy
+
+You are given a **0-indexed** array of strings `words` and a character `x`.
+
+Return _an **array of indices** representing the words that contain the character_ `x`.
+
+**Note** that the returned array may be in **any** order.
+
+**Example 1:**
+
+**Input:** words = ["leet","code"], x = "e"
+
+**Output:** [0,1]
+
+**Explanation:** "e" occurs in both words: "l**<ins>ee</ins>**t", and "cod<ins>**e**</ins>". Hence, we return indices 0 and 1. 
+
+**Example 2:**
+
+**Input:** words = ["abc","bcd","aaaa","cbc"], x = "a"
+
+**Output:** [0,2]
+
+**Explanation:** "a" occurs in "**<ins>a</ins>**bc", and "<ins>**aaaa**</ins>". Hence, we return indices 0 and 2. 
+
+**Example 3:**
+
+**Input:** words = ["abc","bcd","aaaa","cbc"], x = "z"
+
+**Output:** []
+
+**Explanation:** "z" does not occur in any of the words. Hence, we return an empty array. 
+
+**Constraints:**
+
+*   `1 <= words.length <= 50`
+*   `1 <= words[i].length <= 50`
+*   `x` is a lowercase English letter.
+*   `words[i]` consists only of lowercase English letters.

src/main/java/g2901_3000/s2943_maximize_area_of_square_hole_in_grid/Solution.java

@@ -0,0 +1,32 @@
+package g2901_3000.s2943_maximize_area_of_square_hole_in_grid;
+
+// #Medium #Array #Sorting #2024_01_04_Time_2_ms_(100.00%)_Space_43.2_MB_(70.48%)
+
+import java.util.Arrays;
+
+@SuppressWarnings("java:S1172")
+public class Solution {
+    public int maximizeSquareHoleArea(int n, int m, int[] hBars, int[] vBars) {
+        int x = find(hBars);
+        int y = find(vBars);
+        int res = Math.min(x, y) + 1;
+        return res * res;
+    }
+
+    private int find(int[] arr) {
+        Arrays.sort(arr);
+        int res = 1;
+        int i = 0;
+        int n = arr.length;
+        while (i < n) {
+            int count = 1;
+            while (i + 1 < n && arr[i] + 1 == arr[i + 1]) {
+                i++;
+                count++;
+            }
+            i++;
+            res = Math.max(res, count);
+        }
+        return res;
+    }
+}

src/main/java/g2901_3000/s2943_maximize_area_of_square_hole_in_grid/readme.md

@@ -0,0 +1,100 @@
+2943\. Maximize Area of Square Hole in Grid
+
+Medium
+
+There is a grid with `n + 2` **horizontal** bars and `m + 2` **vertical** bars, and initially containing `1 x 1` unit cells.
+
+The bars are **1-indexed**.
+
+You are given the two integers, `n` and `m`.
+
+You are also given two integer arrays: `hBars` and `vBars`.
+
+*   `hBars` contains **distinct** horizontal bars in the range `[2, n + 1]`.
+*   `vBars` contains **distinct** vertical bars in the range `[2, m + 1]`.
+
+You are allowed to **remove** bars that satisfy any of the following conditions:
+
+*   If it is a horizontal bar, it must correspond to a value in `hBars`.
+*   If it is a vertical bar, it must correspond to a value in `vBars`.
+
+Return _an integer denoting the **maximum** area of a **square-shaped** hole in the grid after removing some bars (**possibly none**)._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2023/11/05/screenshot-from-2023-11-05-22-40-25.png)
+
+**Input:** n = 2, m = 1, hBars = [2,3], vBars = [2]
+
+**Output:** 4
+
+**Explanation:** The left image shows the initial grid formed by the bars.
+
+The horizontal bars are in the range [1,4], and the vertical bars are in the range [1,3].
+
+It is allowed to remove horizontal bars [2,3] and the vertical bar [2].
+
+One way to get the maximum square-shaped hole is by removing horizontal bar 2 and vertical bar 2.
+
+The resulting grid is shown on the right.
+
+The hole has an area of 4.
+
+It can be shown that it is not possible to get a square hole with an area more than 4.
+
+Hence, the answer is 4. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2023/11/04/screenshot-from-2023-11-04-17-01-02.png)
+
+**Input:** n = 1, m = 1, hBars = [2], vBars = [2]
+
+**Output:** 4
+
+**Explanation:** The left image shows the initial grid formed by the bars.
+
+The horizontal bars are in the range [1,3], and the vertical bars are in the range [1,3].
+
+It is allowed to remove the horizontal bar [2] and the vertical bar [2].
+
+To get the maximum square-shaped hole, we remove horizontal bar 2 and vertical bar 2.
+
+The resulting grid is shown on the right.
+
+The hole has an area of 4.
+
+Hence, the answer is 4, and it is the maximum possible. 
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2023/11/05/screenshot-from-2023-11-05-22-33-35.png)
+
+**Input:** n = 2, m = 3, hBars = [2,3], vBars = [2,3,4]
+
+**Output:** 9
+
+**Explanation:** The left image shows the initial grid formed by the bars.
+
+The horizontal bars are in the range [1,4], and the vertical bars are in the range [1,5].
+
+It is allowed to remove horizontal bars [2,3] and vertical bars [2,3,4].
+
+One way to get the maximum square-shaped hole is by removing horizontal bars 2 and 3, and vertical bars 3 and 4.
+
+The resulting grid is shown on the right.
+
+The hole has an area of 9.
+
+It can be shown that it is not possible to get a square hole with an area more than 9. Hence, the answer is 9. 
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>9</sup></code>
+*   <code>1 <= m <= 10<sup>9</sup></code>
+*   `1 <= hBars.length <= 100`
+*   `2 <= hBars[i] <= n + 1`
+*   `1 <= vBars.length <= 100`
+*   `2 <= vBars[i] <= m + 1`
+*   All values in `hBars` are distinct.
+*   All values in `vBars` are distinct.

src/main/java/g2901_3000/s2944_minimum_number_of_coins_for_fruits/Solution.java

@@ -0,0 +1,26 @@
+package g2901_3000.s2944_minimum_number_of_coins_for_fruits;
+
+// #Medium #Array #Dynamic_Programming #Heap_Priority_Queue #Queue #Monotonic_Queue
+// #2024_01_04_Time_2_ms_(99.43%)_Space_43.9_MB_(56.19%)
+
+public class Solution {
+    public int minimumCoins(int[] prices) {
+        int n = prices.length;
+        int[] dp = new int[n];
+        dp[n - 1] = prices[n - 1];
+        for (int i = n - 2; i >= 0; i--) {
+            int pos = i + 1;
+            int acquired = i + pos;
+            if (acquired + 1 < n) {
+                int min = Integer.MAX_VALUE;
+                for (int j = acquired + 1; j >= i + 1; j--) {
+                    min = Math.min(min, dp[j]);
+                }
+                dp[i] = prices[i] + min;
+            } else {
+                dp[i] = prices[i];
+            }
+        }
+        return dp[0];
+    }
+}

src/main/java/g2901_3000/s2944_minimum_number_of_coins_for_fruits/readme.md

@@ -0,0 +1,56 @@
+2944\. Minimum Number of Coins for Fruits
+
+Medium
+
+You are at a fruit market with different types of exotic fruits on display.
+
+You are given a **1-indexed** array `prices`, where `prices[i]` denotes the number of coins needed to purchase the <code>i<sup>th</sup></code> fruit.
+
+The fruit market has the following offer:
+
+*   If you purchase the <code>i<sup>th</sup></code> fruit at `prices[i]` coins, you can get the next `i` fruits for free.
+
+**Note** that even if you **can** take fruit `j` for free, you can still purchase it for `prices[j]` coins to receive a new offer.
+
+Return _the **minimum** number of coins needed to acquire all the fruits_.
+
+**Example 1:**
+
+**Input:** prices = [3,1,2]
+
+**Output:** 4
+
+**Explanation:** You can acquire the fruits as follows:
+
+- Purchase the 1<sup>st</sup> fruit with 3 coins, you are allowed to take the 2<sup>nd</sup> fruit for free.
+
+- Purchase the 2<sup>nd</sup> fruit with 1 coin, you are allowed to take the 3<sup>rd</sup> fruit for free.
+
+- Take the 3<sup>rd</sup> fruit for free.
+
+Note that even though you were allowed to take the 2<sup>nd</sup> fruit for free, you purchased it because it is more optimal.
+
+It can be proven that 4 is the minimum number of coins needed to acquire all the fruits. 
+
+**Example 2:**
+
+**Input:** prices = [1,10,1,1]
+
+**Output:** 2
+
+**Explanation:** You can acquire the fruits as follows:
+
+- Purchase the 1<sup>st</sup> fruit with 1 coin, you are allowed to take the 2<sup>nd</sup> fruit for free.
+
+- Take the 2<sup>nd</sup> fruit for free.
+
+- Purchase the 3<sup>rd</sup> fruit for 1 coin, you are allowed to take the 4<sup>th</sup> fruit for free.
+
+- Take the 4<sup>t</sup><sup>h</sup> fruit for free.
+
+It can be proven that 2 is the minimum number of coins needed to acquire all the fruits. 
+
+**Constraints:**
+
+*   `1 <= prices.length <= 1000`
+*   <code>1 <= prices[i] <= 10<sup>5</sup></code>

src/test/java/g2901_3000/s2942_find_words_containing_character/SolutionTest.java

@@ -0,0 +1,30 @@
+package g2901_3000.s2942_find_words_containing_character;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Arrays;
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void findWordsContaining() {
+        assertThat(
+                new Solution().findWordsContaining(new String[] {"leet", "code"}, 'e'),
+                equalTo(Arrays.asList(0, 1)));
+    }
+
+    @Test
+    void findWordsContaining2() {
+        assertThat(
+                new Solution().findWordsContaining(new String[] {"abc", "bcd", "aaaa", "cbc"}, 'a'),
+                equalTo(Arrays.asList(0, 2)));
+    }
+
+    @Test
+    void findWordsContaining3() {
+        assertThat(
+                new Solution().findWordsContaining(new String[] {"abc", "bcd", "aaaa", "cbc"}, 'z'),
+                equalTo(Arrays.asList()));
+    }
+}

src/test/java/g2901_3000/s2943_maximize_area_of_square_hole_in_grid/SolutionTest.java

@@ -0,0 +1,29 @@
+package g2901_3000.s2943_maximize_area_of_square_hole_in_grid;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void maximizeSquareHoleArea() {
+        assertThat(
+                new Solution().maximizeSquareHoleArea(2, 1, new int[] {2, 3}, new int[] {2}),
+                equalTo(4));
+    }
+
+    @Test
+    void maximizeSquareHoleArea2() {
+        assertThat(
+                new Solution().maximizeSquareHoleArea(1, 1, new int[] {2}, new int[] {2}),
+                equalTo(4));
+    }
+
+    @Test
+    void maximizeSquareHoleArea3() {
+        assertThat(
+                new Solution().maximizeSquareHoleArea(2, 3, new int[] {2, 3}, new int[] {2, 3, 4}),
+                equalTo(9));
+    }
+}

src/test/java/g2901_3000/s2944_minimum_number_of_coins_for_fruits/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2901_3000.s2944_minimum_number_of_coins_for_fruits;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minimumCoins() {
+        assertThat(new Solution().minimumCoins(new int[] {3, 1, 2}), equalTo(4));
+    }
+
+    @Test
+    void minimumCoins2() {
+        assertThat(new Solution().minimumCoins(new int[] {1, 10, 1, 1}), equalTo(2));
+    }
+}