Added tasks 2825-2829

Author: ThanhNIT

src/main/java/g2801_2900/s2825_make_string_a_subsequence_using_cyclic_increments/Solution.java

@@ -0,0 +1,24 @@
+package g2801_2900.s2825_make_string_a_subsequence_using_cyclic_increments;
+
+// #Medium #String #Two_Pointers #2023_12_11_Time_5_ms_(99.69%)_Space_44.9_MB_(14.37%)
+
+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/s2825_make_string_a_subsequence_using_cyclic_increments/readme.md

@@ -0,0 +1,41 @@
+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.

src/main/java/g2801_2900/s2826_sorting_three_groups/Solution.java

@@ -0,0 +1,27 @@
+package g2801_2900.s2826_sorting_three_groups;
+
+// #Medium #Array #Dynamic_Programming #2023_12_11_Time_4_ms_(100.00%)_Space_43.5_MB_(79.36%)
+
+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/s2826_sorting_three_groups/readme.md

@@ -0,0 +1,64 @@
+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`

src/main/java/g2801_2900/s2827_number_of_beautiful_integers_in_the_range/Solution.java

@@ -0,0 +1,81 @@
+package g2801_2900.s2827_number_of_beautiful_integers_in_the_range;
+
+// #Hard #Dynamic_Programming #Math #2023_12_11_Time_7_ms_(96.77%)_Space_43.4_MB_(67.74%)
+
+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/s2827_number_of_beautiful_integers_in_the_range/readme.md

@@ -0,0 +1,47 @@
+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`

src/main/java/g2801_2900/s2828_check_if_a_string_is_an_acronym_of_words/Solution.java

@@ -0,0 +1,19 @@
+package g2801_2900.s2828_check_if_a_string_is_an_acronym_of_words;
+
+// #Easy #Array #String #2023_12_11_Time_1_ms_(100.00%)_Space_43.8_MB_(29.48%)
+
+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;
+ }
+}

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

@@ -0,0 +1,40 @@
+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.

src/main/java/g2801_2900/s2829_determine_the_minimum_sum_of_a_k_avoiding_array/Solution.java

@@ -0,0 +1,27 @@
+package g2801_2900.s2829_determine_the_minimum_sum_of_a_k_avoiding_array;
+
+// #Medium #Math #Greedy #2023_12_11_Time_1_ms_(100.00%)_Space_40.6_MB_(77.32%)
+
+public class Solution {
+ public int minimumSum(int n, int k) {
+ int[] arr = new int[n];
+ int a = k / 2;
+ int sum = 0;
+ if (a > n) {
+ for (int i = 0; i < n; i++) {
+ arr[i] = i + 1;
+ sum += arr[i];
+ }
+ } else {
+ for (int i = 0; i < a; i++) {
+ arr[i] = i + 1;
+ sum += arr[i];
+ }
+ for (int j = a; j < n; j++) {
+ arr[j] = k++;
+ sum += arr[j];
+ }
+ }
+ return sum;
+ }
+}