Added tasks 2825-2842

Author: javadev

README.md

@@ -1816,6 +1816,21 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 2842 |[Count K-Subsequences of a String With Maximum Beauty](src/main/java/g2801_2900/s2842_count_k_subsequences_of_a_string_with_maximum_beauty)| Hard | String, Hash_Table, Math, Greedy, Combinatorics | 5 | 80.91
+| 2841 |[Maximum Sum of Almost Unique Subarray](src/main/java/g2801_2900/s2841_maximum_sum_of_almost_unique_subarray)| Medium | Array, Hash_Table, Sliding_Window | 18 | 97.37
+| 2840 |[Check if Strings Can be Made Equal With Operations II](src/main/java/g2801_2900/s2840_check_if_strings_can_be_made_equal_with_operations_ii)| Medium | String, Hash_Table, Sorting | 4 | 100.00
+| 2839 |[Check if Strings Can be Made Equal With Operations I](src/main/java/g2801_2900/s2839_check_if_strings_can_be_made_equal_with_operations_i)| Easy | String | 1 | 99.09
+| 2836 |[Maximize Value of Function in a Ball Passing Game](src/main/java/g2801_2900/s2836_maximize_value_of_function_in_a_ball_passing_game)| Hard | Array, Dynamic_Programming, Bit_Manipulation | 235 | 45.00
+| 2835 |[Minimum Operations to Form Subsequence With Target Sum](src/main/java/g2801_2900/s2835_minimum_operations_to_form_subsequence_with_target_sum)| Hard | Array, Greedy, Bit_Manipulation | 2 | 94.66
+| 2834 |[Find the Minimum Possible Sum of a Beautiful Array](src/main/java/g2801_2900/s2834_find_the_minimum_possible_sum_of_a_beautiful_array)| Medium | Math, Greedy | 0 | 100.00
+| 2833 |[Furthest Point From Origin](src/main/java/g2801_2900/s2833_furthest_point_from_origin)| Easy | Array, Counting | 1 | 100.00
+| 2831 |[Find the Longest Equal Subarray](src/main/java/g2801_2900/s2831_find_the_longest_equal_subarray)| Medium | Array, Hash_Table, Binary_Search, Sliding_Window | 15 | 96.81
+| 2830 |[Maximize the Profit as the Salesman](src/main/java/g2801_2900/s2830_maximize_the_profit_as_the_salesman)| Medium | Array, Dynamic_Programming, Sorting, Binary_Search | 36 | 80.00
+| 2829 |[Determine the Minimum Sum of a k-avoiding Array](src/main/java/g2801_2900/s2829_determine_the_minimum_sum_of_a_k_avoiding_array)| Medium | Math, Greedy | 1 | 100.00
+| 2828 |[Check if a String Is an Acronym of Words](src/main/java/g2801_2900/s2828_check_if_a_string_is_an_acronym_of_words)| Easy | Array, String | 1 | 100.00
+| 2827 |[Number of Beautiful Integers in the Range](src/main/java/g2801_2900/s2827_number_of_beautiful_integers_in_the_range)| Hard | Dynamic_Programming, Math | 7 | 96.77
+| 2826 |[Sorting Three Groups](src/main/java/g2801_2900/s2826_sorting_three_groups)| Medium | Array, Dynamic_Programming | 4 | 100.00
+| 2825 |[Make String a Subsequence Using Cyclic Increments](src/main/java/g2801_2900/s2825_make_string_a_subsequence_using_cyclic_increments)| Medium | String, Two_Pointers | 5 | 99.69
 | 2824 |[Count Pairs Whose Sum is Less than Target](src/main/java/g2801_2900/s2824_count_pairs_whose_sum_is_less_than_target)| Easy | Array, Sorting, Two_Pointers | 2 | 98.16
 | 2818 |[Apply Operations to Maximize Score](src/main/java/g2801_2900/s2818_apply_operations_to_maximize_score)| Hard | Array, Math, Greedy, Stack, Monotonic_Stack, Number_Theory | 94 | 100.00
 | 2817 |[Minimum Absolute Difference Between Elements With Constraint](src/main/java/g2801_2900/s2817_minimum_absolute_difference_between_elements_with_constraint)| Medium | Array, Binary_Search, Ordered_Set | 104 | 96.69

src/main/java/g0301_0400/s0350_intersection_of_two_arrays_ii/readme.md

@@ -59,7 +59,6 @@ public class Solution {
                 // Check if nums2 value is less then nums1 value;
                 // Increment "j"
                 j++;
-
             } else {
                 // Check if nums1 value is equals to nums2 value;
                 // Dump into nums1 and increment k, increment i & increment j as well;

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

@@ -0,0 +1,69 @@
+[![](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)
+
+## 2825\. Make String a Subsequence Using Cyclic Increments
+
+Medium
+
+You are given two **0-indexed** strings `str1` and `str2`.
+
+In an operation, you select a **set** of indices in `str1`, and for each index `i` in the set, increment `str1[i]` to the next character **cyclically**. That is `'a'` becomes `'b'`, `'b'` becomes `'c'`, and so on, and `'z'` becomes `'a'`.
+
+Return `true` _if it is possible to make_ `str2` _a subsequence of_ `str1` _by performing the operation **at most once**_, _and_ `false` _otherwise_.
+
+**Note:** A subsequence of a string is a new string that is formed from the original string by deleting some (possibly none) of the characters without disturbing the relative positions of the remaining characters.
+
+**Example 1:**
+
+**Input:** str1 = "abc", str2 = "ad"
+
+**Output:** true
+
+**Explanation:** Select index 2 in str1. Increment str1[2] to become 'd'. Hence, str1 becomes "abd" and str2 is now a subsequence. Therefore, true is returned.
+
+**Example 2:**
+
+**Input:** str1 = "zc", str2 = "ad"
+
+**Output:** true
+
+**Explanation:** Select indices 0 and 1 in str1. Increment str1[0] to become 'a'. Increment str1[1] to become 'd'. Hence, str1 becomes "ad" and str2 is now a subsequence. Therefore, true is returned.
+
+**Example 3:**
+
+**Input:** str1 = "ab", str2 = "d"
+
+**Output:** false
+
+**Explanation:** In this example, it can be shown that it is impossible to make str2 a subsequence of str1 using the operation at most once. Therefore, false is returned.
+
+**Constraints:**
+
+*   <code>1 <= str1.length <= 10<sup>5</sup></code>
+*   <code>1 <= str2.length <= 10<sup>5</sup></code>
+*   `str1` and `str2` consist of only lowercase English letters.
+
+## Solution
+
+```java
+public class Solution {
+    public boolean canMakeSubsequence(String str1, String str2) {
+        int str1ptr = 0;
+        for (int i = 0; i < str2.length(); i++) {
+            char c2 = str2.charAt(i);
+            boolean found = false;
+            while (str1ptr < str1.length()) {
+                char c1 = str1.charAt(str1ptr++);
+                if (c1 == c2 || (c1 - 'a' + 1) % 26 == c2 - 'a') {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```

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

@@ -0,0 +1,95 @@
+[![](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)
+
+## 2826\. Sorting Three Groups
+
+Medium
+
+You are given a **0-indexed** integer array `nums` of length `n`.
+
+The numbers from `0` to `n - 1` are divided into three groups numbered from `1` to `3`, where number `i` belongs to group `nums[i]`. Notice that some groups may be **empty**.
+
+You are allowed to perform this operation any number of times:
+
+*   Pick number `x` and change its group. More formally, change `nums[x]` to any number from `1` to `3`.
+
+A new array `res` is constructed using the following procedure:
+
+1.  Sort the numbers in each group independently.
+2.  Append the elements of groups `1`, `2`, and `3` to `res` **in this order**.
+
+Array `nums` is called a **beautiful array** if the constructed array `res` is sorted in **non-decreasing** order.
+
+Return _the **minimum** number of operations to make_ `nums` _a **beautiful array**_.
+
+**Example 1:**
+
+**Input:** nums = [2,1,3,2,1]
+
+**Output:** 3
+
+**Explanation:** It's optimal to perform three operations: 
+1. change nums[0] to 1. 
+2. change nums[2] to 1. 
+3. change nums[3] to 1. 
+
+After performing the operations and sorting the numbers in each group, group 1 becomes equal to [0,1,2,3,4] and group 2 and group 3 become empty. Hence, res is equal to [0,1,2,3,4] which is sorted in non-decreasing order. 
+
+It can be proven that there is no valid sequence of less than three operations.
+
+**Example 2:**
+
+**Input:** nums = [1,3,2,1,3,3]
+
+**Output:** 2
+
+**Explanation:** It's optimal to perform two operations: 
+1. change nums[1] to 1. 
+2. change nums[2] to 1. 
+
+After performing the operations and sorting the numbers in each group, group 1 becomes equal to [0,1,2,3], group 2 becomes empty, and group 3 becomes equal to [4,5]. Hence, res is equal to [0,1,2,3,4,5] which is sorted in non-decreasing order. 
+
+It can be proven that there is no valid sequence of less than two operations.
+
+**Example 3:**
+
+**Input:** nums = [2,2,2,2,3,3]
+
+**Output:** 0
+
+**Explanation:** It's optimal to not perform operations. 
+
+After sorting the numbers in each group, group 1 becomes empty, group 2 becomes equal to [0,1,2,3] and group 3 becomes equal to [4,5]. Hence, res is equal to [0,1,2,3,4,5] which is sorted in non-decreasing order.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= nums[i] <= 3`
+
+## Solution
+
+```java
+import java.util.List;
+
+public class Solution {
+    public int minimumOperations(List<Integer> nums) {
+        int n = nums.size();
+        int[] arr = new int[3];
+        int max = 0;
+        for (Integer num : nums) {
+            int locMax = 0;
+            int value = num;
+            for (int j = 0; j < value; j++) {
+                locMax = Math.max(locMax, arr[j]);
+            }
+
+            locMax++;
+            arr[value - 1] = locMax;
+            if (locMax > max) {
+                max = locMax;
+            }
+        }
+        return n - max;
+    }
+}
+```

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

@@ -0,0 +1,132 @@
+[![](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)
+
+## 2827\. Number of Beautiful Integers in the Range
+
+Hard
+
+You are given positive integers `low`, `high`, and `k`.
+
+A number is **beautiful** if it meets both of the following conditions:
+
+*   The count of even digits in the number is equal to the count of odd digits.
+*   The number is divisible by `k`.
+
+Return _the number of beautiful integers in the range_ `[low, high]`.
+
+**Example 1:**
+
+**Input:** low = 10, high = 20, k = 3
+
+**Output:** 2
+
+**Explanation:** There are 2 beautiful integers in the given range: [12,18]. 
+- 12 is beautiful because it contains 1 odd digit and 1 even digit, and is divisible by k = 3. 
+- 18 is beautiful because it contains 1 odd digit and 1 even digit, and is divisible by k = 3. Additionally we can see that: 
+- 16 is not beautiful because it is not divisible by k = 3. 
+- 15 is not beautiful because it does not contain equal counts even and odd digits. It can be shown that there are only 2 beautiful integers in the given range.
+
+**Example 2:**
+
+**Input:** low = 1, high = 10, k = 1
+
+**Output:** 1
+
+**Explanation:** There is 1 beautiful integer in the given range: [10]. 
+- 10 is beautiful because it contains 1 odd digit and 1 even digit, and is divisible by k = 1. It can be shown that there is only 1 beautiful integer in the given range.
+
+**Example 3:**
+
+**Input:** low = 5, high = 5, k = 2
+
+**Output:** 0
+
+**Explanation:** There are 0 beautiful integers in the given range. 
+- 5 is not beautiful because it is not divisible by k = 2 and it does not contain equal even and odd digits.
+
+**Constraints:**
+
+*   <code>0 < low <= high <= 10<sup>9</sup></code>
+*   `0 < k <= 20`
+
+## Solution
+
+```java
+import java.util.Arrays;
+
+@SuppressWarnings("java:S107")
+public class Solution {
+    private int[][][][][] dp;
+    private int maxLength;
+
+    public int numberOfBeautifulIntegers(int low, int high, int k) {
+        String num1 = String.valueOf(low);
+        String num2 = String.valueOf(high);
+        maxLength = Math.max(num1.length(), num2.length());
+        dp = new int[4][maxLength][maxLength][maxLength][k];
+        for (int[][][][] a : dp) {
+            for (int[][][] b : a) {
+                for (int[][] c : b) {
+                    for (int[] d : c) {
+                        Arrays.fill(d, -1);
+                    }
+                }
+            }
+        }
+        return dp(num1, num2, 0, 3, 0, 0, 0, 0, k);
+    }
+
+    private int dp(
+            String low, String high, int i, int mode, int odd, int even, int num, int rem, int k) {
+        if (i == maxLength) {
+            return num % k == 0 && odd == even ? 1 : 0;
+        }
+        if (dp[mode][i][odd][even][rem] != -1) {
+            return dp[mode][i][odd][even][rem];
+        }
+        int res = 0;
+        boolean lowLimit = mode % 2 == 1;
+        boolean highLimit = mode / 2 == 1;
+        int start = 0;
+        int end = 9;
+        if (lowLimit) {
+            start = digitAt(low, i);
+        }
+        if (highLimit) {
+            end = digitAt(high, i);
+        }
+        for (int j = start; j <= end; j++) {
+            int newMode = 0;
+            if (j == start && lowLimit) {
+                newMode += 1;
+            }
+            if (j == end && highLimit) {
+                newMode += 2;
+            }
+            int newEven = even;
+            if (num != 0 || j != 0) {
+                newEven += j % 2 == 0 ? 1 : 0;
+            }
+            int newOdd = odd + (j % 2 == 1 ? 1 : 0);
+            res +=
+                    dp(
+                            low,
+                            high,
+                            i + 1,
+                            newMode,
+                            newOdd,
+                            newEven,
+                            num * 10 + j,
+                            (num * 10 + j) % k,
+                            k);
+        }
+        dp[mode][i][odd][even][rem] = res;
+        return res;
+    }
+
+    private int digitAt(String num, int i) {
+        int index = num.length() - maxLength + i;
+        return index < 0 ? 0 : num.charAt(index) - '0';
+    }
+}
+```

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

@@ -0,0 +1,63 @@
+[![](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)
+
+## 2828\. Check if a String Is an Acronym of Words
+
+Easy
+
+Given an array of strings `words` and a string `s`, determine if `s` is an **acronym** of words.
+
+The string `s` is considered an acronym of `words` if it can be formed by concatenating the **first** character of each string in `words` **in order**. For example, `"ab"` can be formed from `["apple", "banana"]`, but it can't be formed from `["bear", "aardvark"]`.
+
+Return `true` _if_ `s` _is an acronym of_ `words`_, and_ `false` _otherwise._
+
+**Example 1:**
+
+**Input:** words = ["alice","bob","charlie"], s = "abc"
+
+**Output:** true
+
+**Explanation:** The first character in the words "alice", "bob", and "charlie" are 'a', 'b', and 'c', respectively. Hence, s = "abc" is the acronym.
+
+**Example 2:**
+
+**Input:** words = ["an","apple"], s = "a"
+
+**Output:** false
+
+**Explanation:** The first character in the words "an" and "apple" are 'a' and 'a', respectively. The acronym formed by concatenating these characters is "aa". Hence, s = "a" is not the acronym.
+
+**Example 3:**
+
+**Input:** words = ["never","gonna","give","up","on","you"], s = "ngguoy"
+
+**Output:** true
+
+**Explanation:** By concatenating the first character of the words in the array, we get the string "ngguoy". Hence, s = "ngguoy" is the acronym.
+
+**Constraints:**
+
+*   `1 <= words.length <= 100`
+*   `1 <= words[i].length <= 10`
+*   `1 <= s.length <= 100`
+*   `words[i]` and `s` consist of lowercase English letters.
+
+## Solution
+
+```java
+import java.util.List;
+
+public class Solution {
+    public boolean isAcronym(List<String> words, String s) {
+        if (s.length() != words.size()) {
+            return false;
+        }
+        for (int i = 0; i < words.size(); i++) {
+            if (words.get(i).charAt(0) != s.charAt(i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```