Added tasks 3467-3475

Author: javadev

README.md

@@ -2088,10 +2088,19 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3475 |[DNA Pattern Recognition](src/main/java/g3401_3500/s3475_dna_pattern_recognition)| Medium | Database | 362 | 83.49
+| 3474 |[Lexicographically Smallest Generated String](src/main/java/g3401_3500/s3474_lexicographically_smallest_generated_string)| Hard | String, Greedy, String_Matching | 17 | 64.86
+| 3473 |[Sum of K Subarrays With Length at Least M](src/main/java/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m)| Medium | Array, Dynamic_Programming, Prefix_Sum | 191 | 52.16
+| 3472 |[Longest Palindromic Subsequence After at Most K Operations](src/main/java/g3401_3500/s3472_longest_palindromic_subsequence_after_at_most_k_operations)| Medium | String, Dynamic_Programming | 153 | 85.01
+| 3471 |[Find the Largest Almost Missing Integer](src/main/java/g3401_3500/s3471_find_the_largest_almost_missing_integer)| Easy | Array, Hash_Table | 4 | 73.95
+| 3470 |[Permutations IV](src/main/java/g3401_3500/s3470_permutations_iv)| Hard | Array, Math, Enumeration, Combinatorics | 11 | 59.56
+| 3469 |[Find Minimum Cost to Remove Array Elements](src/main/java/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements)| Medium | Array, Dynamic_Programming | 12 | 100.00
+| 3468 |[Find the Number of Copy Arrays](src/main/java/g3401_3500/s3468_find_the_number_of_copy_arrays)| Medium | Array, Math | 2 | 100.00
+| 3467 |[Transform Array by Parity](src/main/java/g3401_3500/s3467_transform_array_by_parity)| Easy | Array, Sorting, Counting | 1 | 100.00
 | 3465 |[Find Products with Valid Serial Numbers](src/main/java/g3401_3500/s3465_find_products_with_valid_serial_numbers)| Easy | Database | 292 | 90.91
 | 3464 |[Maximize the Distance Between Points on a Square](src/main/java/g3401_3500/s3464_maximize_the_distance_between_points_on_a_square)| Hard | Array, Greedy, Binary_Search | 17 | 98.18
 | 3463 |[Check If Digits Are Equal in String After Operations II](src/main/java/g3401_3500/s3463_check_if_digits_are_equal_in_string_after_operations_ii)| Hard | String, Math, Number_Theory, Combinatorics | 43 | 99.64
-| 3462 |[Maximum Sum With at Most K Elements](src/main/java/g3401_3500/s3462_maximum_sum_with_at_most_k_elements)| Medium | Array, Sorting, Greedy, Matrix, Heap_(Priority_Queue) | 62 | 99.82
+| 3462 |[Maximum Sum With at Most K Elements](src/main/java/g3401_3500/s3462_maximum_sum_with_at_most_k_elements)| Medium | Array, Sorting, Greedy, Matrix, Heap_Priority_Queue | 62 | 99.82
 | 3461 |[Check If Digits Are Equal in String After Operations I](src/main/java/g3401_3500/s3461_check_if_digits_are_equal_in_string_after_operations_i)| Easy | String, Math, Simulation, Number_Theory, Combinatorics | 2 | 96.71
 | 3459 |[Length of Longest V-Shaped Diagonal Segment](src/main/java/g3401_3500/s3459_length_of_longest_v_shaped_diagonal_segment)| Hard | Array, Dynamic_Programming, Matrix, Memoization | 56 | 72.97
 | 3458 |[Select K Disjoint Special Substrings](src/main/java/g3401_3500/s3458_select_k_disjoint_special_substrings)| Medium | String, Hash_Table, Dynamic_Programming, Sorting, Greedy | 7 | 95.31

src/main/java/g3401_3500/s3462_maximum_sum_with_at_most_k_elements/readme.md

@@ -52,8 +52,8 @@ import java.util.Arrays;
 public class Solution {
     public long maxSum(int[][] grid, int[] limits, int k) {
         int l = 0;
-        for (int i = 0; i < limits.length; i++) {
-            l += limits[i];
+        for (int limit : limits) {
+            l += limit;
         }
         int[] dp = new int[l];
         int a = 0;

src/main/java/g3401_3500/s3467_transform_array_by_parity/readme.md

@@ -0,0 +1,62 @@
+[![](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)
+
+## 3467\. Transform Array by Parity
+
+Easy
+
+You are given an integer array `nums`. Transform `nums` by performing the following operations in the **exact** order specified:
+
+1.  Replace each even number with 0.
+2.  Replace each odd numbers with 1.
+3.  Sort the modified array in **non-decreasing** order.
+
+Return the resulting array after performing these operations.
+
+**Example 1:**
+
+**Input:** nums = [4,3,2,1]
+
+**Output:** [0,0,1,1]
+
+**Explanation:**
+
+*   Replace the even numbers (4 and 2) with 0 and the odd numbers (3 and 1) with 1. Now, `nums = [0, 1, 0, 1]`.
+*   After sorting `nums` in non-descending order, `nums = [0, 0, 1, 1]`.
+
+**Example 2:**
+
+**Input:** nums = [1,5,1,4,2]
+
+**Output:** [0,0,1,1,1]
+
+**Explanation:**
+
+*   Replace the even numbers (4 and 2) with 0 and the odd numbers (1, 5 and 1) with 1. Now, `nums = [1, 1, 1, 0, 0]`.
+*   After sorting `nums` in non-descending order, `nums = [0, 0, 1, 1, 1]`.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= nums[i] <= 1000`
+
+## Solution
+
+```java
+public class Solution {
+    public int[] transformArray(int[] nums) {
+        int size = nums.length;
+        int[] ans = new int[size];
+        int countEven = 0;
+        for (int num : nums) {
+            if ((num & 1) == 0) {
+                countEven++;
+            }
+        }
+        for (int i = countEven; i < size; i++) {
+            ans[i] = 1;
+        }
+        return ans;
+    }
+}
+```

src/main/java/g3401_3500/s3468_find_the_number_of_copy_arrays/readme.md

@@ -0,0 +1,80 @@
+[![](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)
+
+## 3468\. Find the Number of Copy Arrays
+
+Medium
+
+You are given an array `original` of length `n` and a 2D array `bounds` of length `n x 2`, where <code>bounds[i] = [u<sub>i</sub>, v<sub>i</sub>]</code>.
+
+You need to find the number of **possible** arrays `copy` of length `n` such that:
+
+1.  `(copy[i] - copy[i - 1]) == (original[i] - original[i - 1])` for `1 <= i <= n - 1`.
+2.  <code>u<sub>i</sub> <= copy[i] <= v<sub>i</sub></code> for `0 <= i <= n - 1`.
+
+Return the number of such arrays.
+
+**Example 1:**
+
+**Input:** original = [1,2,3,4], bounds = \[\[1,2],[2,3],[3,4],[4,5]]
+
+**Output:** 2
+
+**Explanation:**
+
+The possible arrays are:
+
+*   `[1, 2, 3, 4]`
+*   `[2, 3, 4, 5]`
+
+**Example 2:**
+
+**Input:** original = [1,2,3,4], bounds = \[\[1,10],[2,9],[3,8],[4,7]]
+
+**Output:** 4
+
+**Explanation:**
+
+The possible arrays are:
+
+*   `[1, 2, 3, 4]`
+*   `[2, 3, 4, 5]`
+*   `[3, 4, 5, 6]`
+*   `[4, 5, 6, 7]`
+
+**Example 3:**
+
+**Input:** original = [1,2,1,2], bounds = \[\[1,1],[2,3],[3,3],[2,3]]
+
+**Output:** 0
+
+**Explanation:**
+
+No array is possible.
+
+**Constraints:**
+
+*   <code>2 <= n == original.length <= 10<sup>5</sup></code>
+*   <code>1 <= original[i] <= 10<sup>9</sup></code>
+*   `bounds.length == n`
+*   `bounds[i].length == 2`
+*   <code>1 <= bounds[i][0] <= bounds[i][1] <= 10<sup>9</sup></code>
+
+## Solution
+
+```java
+public class Solution {
+    public int countArrays(int[] original, int[][] bounds) {
+        int low = bounds[0][0];
+        int high = bounds[0][1];
+        int ans = high - low + 1;
+        for (int i = 1; i < original.length; ++i) {
+            int diff = original[i] - original[i - 1];
+            low = Math.max(low + diff, bounds[i][0]);
+            high = Math.min(high + diff, bounds[i][1]);
+            ans = Math.min(ans, high - low + 1);
+        }
+        return Math.max(ans, 0);
+    }
+}
+```

src/main/java/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/readme.md

@@ -0,0 +1,83 @@
+[![](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)
+
+## 3469\. Find Minimum Cost to Remove Array Elements
+
+Medium
+
+You are given an integer array `nums`. Your task is to remove **all elements** from the array by performing one of the following operations at each step until `nums` is empty:
+
+*   Choose any two elements from the first three elements of `nums` and remove them. The cost of this operation is the **maximum** of the two elements removed.
+*   If fewer than three elements remain in `nums`, remove all the remaining elements in a single operation. The cost of this operation is the **maximum** of the remaining elements.
+
+Return the **minimum** cost required to remove all the elements.
+
+**Example 1:**
+
+**Input:** nums = [6,2,8,4]
+
+**Output:** 12
+
+**Explanation:**
+
+Initially, `nums = [6, 2, 8, 4]`.
+
+*   In the first operation, remove `nums[0] = 6` and `nums[2] = 8` with a cost of `max(6, 8) = 8`. Now, `nums = [2, 4]`.
+*   In the second operation, remove the remaining elements with a cost of `max(2, 4) = 4`.
+
+The cost to remove all elements is `8 + 4 = 12`. This is the minimum cost to remove all elements in `nums`. Hence, the output is 12.
+
+**Example 2:**
+
+**Input:** nums = [2,1,3,3]
+
+**Output:** 5
+
+**Explanation:**
+
+Initially, `nums = [2, 1, 3, 3]`.
+
+*   In the first operation, remove `nums[0] = 2` and `nums[1] = 1` with a cost of `max(2, 1) = 2`. Now, `nums = [3, 3]`.
+*   In the second operation remove the remaining elements with a cost of `max(3, 3) = 3`.
+
+The cost to remove all elements is `2 + 3 = 5`. This is the minimum cost to remove all elements in `nums`. Hence, the output is 5.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   <code>1 <= nums[i] <= 10<sup>6</sup></code>
+
+## Solution
+
+```java
+import java.util.Arrays;
+
+public class Solution {
+    private static final int INF = (int) 1e9;
+
+    public int minCost(int[] nums) {
+        int n = nums.length;
+        if (n % 2 == 0) {
+            nums = Arrays.copyOf(nums, ++n);
+        }
+        int[] dp = new int[n];
+        for (int j = 1; j < n - 1; j += 2) {
+            int cost1 = INF;
+            int cost2 = INF;
+            int max = Math.max(nums[j], nums[j + 1]);
+            for (int i = 0; i < j; ++i) {
+                cost1 = Math.min(cost1, dp[i] + Math.max(nums[i], nums[j + 1]));
+                cost2 = Math.min(cost2, dp[i] + Math.max(nums[i], nums[j]));
+                dp[i] += max;
+            }
+            dp[j] = cost1;
+            dp[j + 1] = cost2;
+        }
+        int result = INF;
+        for (int i = 0; i < n; ++i) {
+            result = Math.min(result, dp[i] + nums[i]);
+        }
+        return result;
+    }
+}
+```