Added tasks 3216-3229

Author: javadev

README.md

@@ -1816,6 +1816,19 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3229 |[Minimum Operations to Make Array Equal to Target](src/main/java/g3201_3300/s3229_minimum_operations_to_make_array_equal_to_target)| Hard | Array, Dynamic_Programming, Greedy, Stack, Monotonic_Stack | 2 | 100.00
+| 3228 |[Maximum Number of Operations to Move Ones to the End](src/main/java/g3201_3300/s3228_maximum_number_of_operations_to_move_ones_to_the_end)| Medium | String, Greedy, Counting | 5 | 100.00
+| 3227 |[Vowels Game in a String](src/main/java/g3201_3300/s3227_vowels_game_in_a_string)| Medium | String, Math, Game_Theory, Brainteaser | 4 | 96.15
+| 3226 |[Number of Bit Changes to Make Two Integers Equal](src/main/java/g3201_3300/s3226_number_of_bit_changes_to_make_two_integers_equal)| Easy | Bit_Manipulation | 0 | 100.00
+| 3225 |[Maximum Score From Grid Operations](src/main/java/g3201_3300/s3225_maximum_score_from_grid_operations)| Hard | Array, Dynamic_Programming, Matrix, Prefix_Sum | 21 | 100.00
+| 3224 |[Minimum Array Changes to Make Differences Equal](src/main/java/g3201_3300/s3224_minimum_array_changes_to_make_differences_equal)| Medium | Array, Hash_Table, Prefix_Sum | 4 | 100.00
+| 3223 |[Minimum Length of String After Operations](src/main/java/g3201_3300/s3223_minimum_length_of_string_after_operations)| Medium | String, Hash_Table, Counting | 9 | 94.23
+| 3222 |[Find the Winning Player in Coin Game](src/main/java/g3201_3300/s3222_find_the_winning_player_in_coin_game)| Easy | Math, Simulation, Game_Theory | 0 | 100.00
+| 3220 |[Odd and Even Transactions](src/main/java/g3201_3300/s3220_odd_and_even_transactions)| Medium | Database | 248 | 85.85
+| 3219 |[Minimum Cost for Cutting Cake II](src/main/java/g3201_3300/s3219_minimum_cost_for_cutting_cake_ii)| Hard | Array, Sorting, Greedy | 3 | 100.00
+| 3218 |[Minimum Cost for Cutting Cake I](src/main/java/g3201_3300/s3218_minimum_cost_for_cutting_cake_i)| Medium | Array, Dynamic_Programming, Sorting, Greedy | 0 | 100.00
+| 3217 |[Delete Nodes From Linked List Present in Array](src/main/java/g3201_3300/s3217_delete_nodes_from_linked_list_present_in_array)| Medium | Array, Hash_Table, Linked_List | 3 | 100.00
+| 3216 |[Lexicographically Smallest String After a Swap](src/main/java/g3201_3300/s3216_lexicographically_smallest_string_after_a_swap)| Easy | String, Greedy | 1 | 100.00
 | 3213 |[Construct String with Minimum Cost](src/main/java/g3201_3300/s3213_construct_string_with_minimum_cost)| Hard | Array, String, Dynamic_Programming, Suffix_Array | 261 | 88.55
 | 3212 |[Count Submatrices With Equal Frequency of X and Y](src/main/java/g3201_3300/s3212_count_submatrices_with_equal_frequency_of_x_and_y)| Medium | Array, Matrix, Prefix_Sum | 15 | 100.00
 | 3211 |[Generate Binary Strings Without Adjacent Zeros](src/main/java/g3201_3300/s3211_generate_binary_strings_without_adjacent_zeros)| Medium | String, Bit_Manipulation, Recursion | 1 | 100.00

src/main/java/g3201_3300/s3216_lexicographically_smallest_string_after_a_swap/readme.md

@@ -0,0 +1,54 @@
+[![](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)
+
+## 3216\. Lexicographically Smallest String After a Swap
+
+Easy
+
+Given a string `s` containing only digits, return the lexicographically smallest string that can be obtained after swapping **adjacent** digits in `s` with the same **parity** at most **once**.
+
+Digits have the same parity if both are odd or both are even. For example, 5 and 9, as well as 2 and 4, have the same parity, while 6 and 9 do not.
+
+**Example 1:**
+
+**Input:** s = "45320"
+
+**Output:** "43520"
+
+**Explanation:**
+
+`s[1] == '5'` and `s[2] == '3'` both have the same parity, and swapping them results in the lexicographically smallest string.
+
+**Example 2:**
+
+**Input:** s = "001"
+
+**Output:** "001"
+
+**Explanation:**
+
+There is no need to perform a swap because `s` is already the lexicographically smallest.
+
+**Constraints:**
+
+*   `2 <= s.length <= 100`
+*   `s` consists only of digits.
+
+## Solution
+
+```java
+public class Solution {
+    public String getSmallestString(String s) {
+        final char[] arr = s.toCharArray();
+        for (int i = 1; i < arr.length; i++) {
+            if (arr[i - 1] % 2 == arr[i] % 2 && arr[i - 1] > arr[i]) {
+                final char temp = arr[i];
+                arr[i] = arr[i - 1];
+                arr[i - 1] = temp;
+                break;
+            }
+        }
+        return String.valueOf(arr);
+    }
+}
+```

src/main/java/g3201_3300/s3217_delete_nodes_from_linked_list_present_in_array/readme.md

@@ -0,0 +1,90 @@
+[![](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)
+
+## 3217\. Delete Nodes From Linked List Present in Array
+
+Medium
+
+You are given an array of integers `nums` and the `head` of a linked list. Return the `head` of the modified linked list after **removing** all nodes from the linked list that have a value that exists in `nums`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3], head = [1,2,3,4,5]
+
+**Output:** [4,5]
+
+**Explanation:**
+
+**![](https://assets.leetcode.com/uploads/2024/06/11/linkedlistexample0.png)**
+
+Remove the nodes with values 1, 2, and 3.
+
+**Example 2:**
+
+**Input:** nums = [1], head = [1,2,1,2,1,2]
+
+**Output:** [2,2,2]
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/06/11/linkedlistexample1.png)
+
+Remove the nodes with value 1.
+
+**Example 3:**
+
+**Input:** nums = [5], head = [1,2,3,4]
+
+**Output:** [1,2,3,4]
+
+**Explanation:**
+
+**![](https://assets.leetcode.com/uploads/2024/06/11/linkedlistexample2.png)**
+
+No node has value 5.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>
+*   All elements in `nums` are unique.
+*   The number of nodes in the given list is in the range <code>[1, 10<sup>5</sup>]</code>.
+*   <code>1 <= Node.val <= 10<sup>5</sup></code>
+*   The input is generated such that there is at least one node in the linked list that has a value not present in `nums`.
+
+## Solution
+
+```java
+import com_github_leetcode.ListNode;
+
+
+/**
+ * Definition for singly-linked list. public class ListNode { int val; ListNode next; ListNode() {}
+ * ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val;
+ * this.next = next; } }
+ */
+public class Solution {
+    public ListNode modifiedList(int[] nums, ListNode head) {
+        int maxv = 0;
+        for (int v : nums) {
+            maxv = Math.max(maxv, v);
+        }
+        boolean[] rem = new boolean[maxv + 1];
+        for (int v : nums) {
+            rem[v] = true;
+        }
+        ListNode h = new ListNode(0);
+        ListNode t = h;
+        ListNode p = head;
+        while (p != null) {
+            if (p.val > maxv || !rem[p.val]) {
+                t.next = p;
+                t = p;
+            }
+            p = p.next;
+        }
+        t.next = null;
+        return h.next;
+    }
+}
+```

src/main/java/g3201_3300/s3218_minimum_cost_for_cutting_cake_i/readme.md

@@ -0,0 +1,86 @@
+[![](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)
+
+## 3218\. Minimum Cost for Cutting Cake I
+
+Medium
+
+There is an `m x n` cake that needs to be cut into `1 x 1` pieces.
+
+You are given integers `m`, `n`, and two arrays:
+
+*   `horizontalCut` of size `m - 1`, where `horizontalCut[i]` represents the cost to cut along the horizontal line `i`.
+*   `verticalCut` of size `n - 1`, where `verticalCut[j]` represents the cost to cut along the vertical line `j`.
+
+In one operation, you can choose any piece of cake that is not yet a `1 x 1` square and perform one of the following cuts:
+
+1.  Cut along a horizontal line `i` at a cost of `horizontalCut[i]`.
+2.  Cut along a vertical line `j` at a cost of `verticalCut[j]`.
+
+After the cut, the piece of cake is divided into two distinct pieces.
+
+The cost of a cut depends only on the initial cost of the line and does not change.
+
+Return the **minimum** total cost to cut the entire cake into `1 x 1` pieces.
+
+**Example 1:**
+
+**Input:** m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
+
+**Output:** 13
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/06/04/ezgifcom-animated-gif-maker-1.gif)
+
+*   Perform a cut on the vertical line 0 with cost 5, current total cost is 5.
+*   Perform a cut on the horizontal line 0 on `3 x 1` subgrid with cost 1.
+*   Perform a cut on the horizontal line 0 on `3 x 1` subgrid with cost 1.
+*   Perform a cut on the horizontal line 1 on `2 x 1` subgrid with cost 3.
+*   Perform a cut on the horizontal line 1 on `2 x 1` subgrid with cost 3.
+
+The total cost is `5 + 1 + 1 + 3 + 3 = 13`.
+
+**Example 2:**
+
+**Input:** m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
+
+**Output:** 15
+
+**Explanation:**
+
+*   Perform a cut on the horizontal line 0 with cost 7.
+*   Perform a cut on the vertical line 0 on `1 x 2` subgrid with cost 4.
+*   Perform a cut on the vertical line 0 on `1 x 2` subgrid with cost 4.
+
+The total cost is `7 + 4 + 4 = 15`.
+
+**Constraints:**
+
+*   `1 <= m, n <= 20`
+*   `horizontalCut.length == m - 1`
+*   `verticalCut.length == n - 1`
+*   <code>1 <= horizontalCut[i], verticalCut[i] <= 10<sup>3</sup></code>
+
+## Solution
+
+```java
+@SuppressWarnings("java:S1172")
+public class Solution {
+    public int minimumCost(int m, int n, int[] horizontalCut, int[] verticalCut) {
+        int sum = 0;
+        for (int hc : horizontalCut) {
+            sum += hc;
+        }
+        for (int vc : verticalCut) {
+            sum += vc;
+        }
+        for (int hc : horizontalCut) {
+            for (int vc : verticalCut) {
+                sum += Math.min(hc, vc);
+            }
+        }
+        return sum;
+    }
+}
+```

src/main/java/g3201_3300/s3219_minimum_cost_for_cutting_cake_ii/readme.md

@@ -0,0 +1,102 @@
+[![](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)
+
+## 3219\. Minimum Cost for Cutting Cake II
+
+Hard
+
+There is an `m x n` cake that needs to be cut into `1 x 1` pieces.
+
+You are given integers `m`, `n`, and two arrays:
+
+*   `horizontalCut` of size `m - 1`, where `horizontalCut[i]` represents the cost to cut along the horizontal line `i`.
+*   `verticalCut` of size `n - 1`, where `verticalCut[j]` represents the cost to cut along the vertical line `j`.
+
+In one operation, you can choose any piece of cake that is not yet a `1 x 1` square and perform one of the following cuts:
+
+1.  Cut along a horizontal line `i` at a cost of `horizontalCut[i]`.
+2.  Cut along a vertical line `j` at a cost of `verticalCut[j]`.
+
+After the cut, the piece of cake is divided into two distinct pieces.
+
+The cost of a cut depends only on the initial cost of the line and does not change.
+
+Return the **minimum** total cost to cut the entire cake into `1 x 1` pieces.
+
+**Example 1:**
+
+**Input:** m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
+
+**Output:** 13
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/06/04/ezgifcom-animated-gif-maker-1.gif)
+
+*   Perform a cut on the vertical line 0 with cost 5, current total cost is 5.
+*   Perform a cut on the horizontal line 0 on `3 x 1` subgrid with cost 1.
+*   Perform a cut on the horizontal line 0 on `3 x 1` subgrid with cost 1.
+*   Perform a cut on the horizontal line 1 on `2 x 1` subgrid with cost 3.
+*   Perform a cut on the horizontal line 1 on `2 x 1` subgrid with cost 3.
+
+The total cost is `5 + 1 + 1 + 3 + 3 = 13`.
+
+**Example 2:**
+
+**Input:** m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
+
+**Output:** 15
+
+**Explanation:**
+
+*   Perform a cut on the horizontal line 0 with cost 7.
+*   Perform a cut on the vertical line 0 on `1 x 2` subgrid with cost 4.
+*   Perform a cut on the vertical line 0 on `1 x 2` subgrid with cost 4.
+
+The total cost is `7 + 4 + 4 = 15`.
+
+**Constraints:**
+
+*   <code>1 <= m, n <= 10<sup>5</sup></code>
+*   `horizontalCut.length == m - 1`
+*   `verticalCut.length == n - 1`
+*   <code>1 <= horizontalCut[i], verticalCut[i] <= 10<sup>3</sup></code>
+
+## Solution
+
+```java
+@SuppressWarnings("java:S1172")
+public class Solution {
+    private static final int N = 1001;
+
+    public long minimumCost(int m, int n, int[] horizontalCut, int[] verticalCut) {
+        int[] horizontalCounts = new int[N];
+        int[] verticalCounts = new int[N];
+        int max = 0;
+        for (int x : horizontalCut) {
+            if (x > max) {
+                max = x;
+            }
+            horizontalCounts[x]++;
+        }
+        for (int x : verticalCut) {
+            if (x > max) {
+                max = x;
+            }
+            verticalCounts[x]++;
+        }
+        long ans = 0;
+        int horizontalCount = 1;
+        int verticalCount = 1;
+        for (int x = max; x > 0; x--) {
+            ans += (long) horizontalCounts[x] * x * horizontalCount;
+            verticalCount += horizontalCounts[x];
+            horizontalCounts[x] = 0;
+            ans += (long) verticalCounts[x] * x * verticalCount;
+            horizontalCount += verticalCounts[x];
+            verticalCounts[x] = 0;
+        }
+        return ans;
+    }
+}
+```