Added tasks 2262, 2264, 2265, 2266, 2267, 2269, 2270, 2274, 2299.

Author: javadev

README.md

@@ -1334,9 +1334,18 @@
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
 | 2300 |[Successful Pairs of Spells and Potions](src/main/java/g2201_2300/s2300_successful_pairs_of_spells_and_potions)| Medium | Array, Two_Pointers, Binary_Search, Sorting | 85 | 71.70
+| 2299 |[Strong Password Checker II](src/main/java/g2201_2300/s2299_strong_password_checker_ii)| Easy | String | 1 | 97.32
 | 2293 |[Min Max Game](src/main/java/g2201_2300/s2293_min_max_game)| Easy | Array, Simulation | 1 | 90.39
 | 2286 |[Booking Concert Tickets in Groups](src/main/java/g2201_2300/s2286_booking_concert_tickets_in_groups)| Hard | Binary_Search, Design, Binary_Indexed_Tree, Segment_Tree | 283 | 67.08
 | 2280 |[Minimum Lines to Represent a Line Chart](src/main/java/g2201_2300/s2280_minimum_lines_to_represent_a_line_chart)| Medium | Array, Math, Geometry, Sorting, Number_Theory | 40 | 96.09
+| 2274 |[Maximum Consecutive Floors Without Special Floors](src/main/java/g2201_2300/s2274_maximum_consecutive_floors_without_special_floors)| Medium | Array, Sorting | 33 | 99.36
+| 2270 |[Number of Ways to Split Array](src/main/java/g2201_2300/s2270_number_of_ways_to_split_array)| Medium | Array, Prefix_Sum | 4 | 77.55
+| 2269 |[Find the K-Beauty of a Number](src/main/java/g2201_2300/s2269_find_the_k_beauty_of_a_number)| Easy | Math, String, Sliding_Window | 2 | 38.88
+| 2267 |[Check if There Is a Valid Parentheses String Path](src/main/java/g2201_2300/s2267_check_if_there_is_a_valid_parentheses_string_path)| Hard | Array, Dynamic_Programming, Matrix | 93 | 77.48
+| 2266 |[Count Number of Texts](src/main/java/g2201_2300/s2266_count_number_of_texts)| Medium | Hash_Table, Math, String, Dynamic_Programming | 38 | 81.43
+| 2265 |[Count Nodes Equal to Average of Subtree](src/main/java/g2201_2300/s2265_count_nodes_equal_to_average_of_subtree)| Medium | Tree, Depth_First_Search, Binary_Tree | 1 | 99.12
+| 2264 |[Largest 3-Same-Digit Number in String](src/main/java/g2201_2300/s2264_largest_3_same_digit_number_in_string)| Easy | String | 3 | 74.57
+| 2262 |[Total Appeal of A String](src/main/java/g2201_2300/s2262_total_appeal_of_a_string)| Hard | Hash_Table, String, Dynamic_Programming | 6 | 97.92
 | 2260 |[Minimum Consecutive Cards to Pick Up](src/main/java/g2201_2300/s2260_minimum_consecutive_cards_to_pick_up)| Medium | Array, Hash_Table, Sliding_Window | 50 | 97.04
 | 2259 |[Remove Digit From Number to Maximize Result](src/main/java/g2201_2300/s2259_remove_digit_from_number_to_maximize_result)| Easy | String, Greedy, Enumeration | 1 | 97.73
 | 2257 |[Count Unguarded Cells in the Grid](src/main/java/g2201_2300/s2257_count_unguarded_cells_in_the_grid)| Medium | Array, Matrix, Simulation | 32 | 70.28

src/main/java/g2201_2300/s2262_total_appeal_of_a_string/readme.md

@@ -0,0 +1,75 @@
+## 2262\. Total Appeal of A String
+
+Hard
+
+The **appeal** of a string is the number of **distinct** characters found in the string.
+
+*   For example, the appeal of `"abbca"` is `3` because it has `3` distinct characters: `'a'`, `'b'`, and `'c'`.
+
+Given a string `s`, return _the **total appeal of all of its **substrings**.**_
+
+A **substring** is a contiguous sequence of characters within a string.
+
+**Example 1:**
+
+**Input:** s = "abbca"
+
+**Output:** 28
+
+**Explanation:** The following are the substrings of "abbca":
+
+- Substrings of length 1: "a", "b", "b", "c", "a" have an appeal of 1, 1, 1, 1, and 1 respectively. The sum is 5.
+
+- Substrings of length 2: "ab", "bb", "bc", "ca" have an appeal of 2, 1, 2, and 2 respectively. The sum is 7.
+
+- Substrings of length 3: "abb", "bbc", "bca" have an appeal of 2, 2, and 3 respectively. The sum is 7.
+
+- Substrings of length 4: "abbc", "bbca" have an appeal of 3 and 3 respectively. The sum is 6.
+
+- Substrings of length 5: "abbca" has an appeal of 3. The sum is 3.
+
+The total sum is 5 + 7 + 7 + 6 + 3 = 28. 
+
+**Example 2:**
+
+**Input:** s = "code"
+
+**Output:** 20
+
+**Explanation:** The following are the substrings of "code":
+
+- Substrings of length 1: "c", "o", "d", "e" have an appeal of 1, 1, 1, and 1 respectively. The sum is 4.
+
+- Substrings of length 2: "co", "od", "de" have an appeal of 2, 2, and 2 respectively. The sum is 6.
+
+- Substrings of length 3: "cod", "ode" have an appeal of 3 and 3 respectively. The sum is 6.
+
+- Substrings of length 4: "code" has an appeal of 4. The sum is 4.
+
+The total sum is 4 + 6 + 6 + 4 = 20. 
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of lowercase English letters.
+
+## Solution
+
+```java
+import java.util.Arrays;
+
+public class Solution {
+    public long appealSum(String s) {
+        int len = s.length();
+        int[] lastPos = new int[26];
+        Arrays.fill(lastPos, -1);
+        long res = 0;
+        for (int i = 0; i < len; i++) {
+            int idx = s.charAt(i) - 'a';
+            res += (i - lastPos[idx]) * (len - i);
+            lastPos[idx] = i;
+        }
+        return res;
+    }
+}
+```

src/main/java/g2201_2300/s2264_largest_3_same_digit_number_in_string/readme.md

@@ -0,0 +1,70 @@
+## 2264\. Largest 3-Same-Digit Number in String
+
+Easy
+
+You are given a string `num` representing a large integer. An integer is **good** if it meets the following conditions:
+
+*   It is a **substring** of `num` with length `3`.
+*   It consists of only one unique digit.
+
+Return _the **maximum good** integer as a **string** or an empty string_ `""` _if no such integer exists_.
+
+Note:
+
+*   A **substring** is a contiguous sequence of characters within a string.
+*   There may be **leading zeroes** in `num` or a good integer.
+
+**Example 1:**
+
+**Input:** num = "6**777**133339"
+
+**Output:** "777"
+
+**Explanation:** There are two distinct good integers: "777" and "333".
+
+"777" is the largest, so we return "777". 
+
+**Example 2:**
+
+**Input:** num = "23**000**19"
+
+**Output:** "000"
+
+**Explanation:** "000" is the only good integer.
+
+**Example 3:**
+
+**Input:** num = "42352338"
+
+**Output:** ""
+
+**Explanation:** No substring of length 3 consists of only one unique digit. Therefore, there are no good integers.
+
+**Constraints:**
+
+*   `3 <= num.length <= 1000`
+*   `num` only consists of digits.
+
+## Solution
+
+```java
+public class Solution {
+    public String largestGoodInteger(String num) {
+        String maxi = "000";
+        int c = 0;
+        for (int i = 0; i < num.length() - 2; i++) {
+            String s = num.substring(i, i + 3);
+            if (s.charAt(0) == s.charAt(1) && s.charAt(1) == s.charAt(2)) {
+                if (s.compareTo(maxi) >= 0) {
+                    maxi = s;
+                }
+                ++c;
+            }
+        }
+        if (c == 0) {
+            return "";
+        }
+        return maxi;
+    }
+}
+```

src/main/java/g2201_2300/s2265_count_nodes_equal_to_average_of_subtree/readme.md

@@ -0,0 +1,74 @@
+## 2265\. Count Nodes Equal to Average of Subtree
+
+Medium
+
+Given the `root` of a binary tree, return _the number of nodes where the value of the node is equal to the **average** of the values in its **subtree**_.
+
+**Note:**
+
+*   The **average** of `n` elements is the **sum** of the `n` elements divided by `n` and **rounded down** to the nearest integer.
+*   A **subtree** of `root` is a tree consisting of `root` and all of its descendants.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/03/15/image-20220315203925-1.png)
+
+**Input:** root = [4,8,5,0,1,null,6]
+
+**Output:** 5
+
+**Explanation:**
+
+For the node with value 4: The average of its subtree is (4 + 8 + 5 + 0 + 1 + 6) / 6 = 24 / 6 = 4.
+
+For the node with value 5: The average of its subtree is (5 + 6) / 2 = 11 / 2 = 5.
+
+For the node with value 0: The average of its subtree is 0 / 1 = 0.
+
+For the node with value 1: The average of its subtree is 1 / 1 = 1.
+
+For the node with value 6: The average of its subtree is 6 / 1 = 6.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/03/26/image-20220326133920-1.png)
+
+**Input:** root = [1]
+
+**Output:** 1
+
+**Explanation:** For the node with value 1: The average of its subtree is 1 / 1 = 1.
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[1, 1000]`.
+*   `0 <= Node.val <= 1000`
+
+## Solution
+
+```java
+import com_github_leetcode.TreeNode;
+
+public class Solution {
+    private int ans = 0;
+
+    public int averageOfSubtree(TreeNode root) {
+        dfs(root);
+        return ans;
+    }
+
+    private int[] dfs(TreeNode node) {
+        if (node == null) {
+            return new int[] {0, 0};
+        }
+        int[] left = dfs(node.left);
+        int[] right = dfs(node.right);
+        int currsum = left[0] + right[0] + node.val;
+        int currcount = left[1] + right[1] + 1;
+        if (currsum / currcount == node.val) {
+            ++ans;
+        }
+        return new int[] {currsum, currcount};
+    }
+}
+```

src/main/java/g2201_2300/s2266_count_number_of_texts/readme.md

@@ -0,0 +1,92 @@
+## 2266\. Count Number of Texts
+
+Medium
+
+Alice is texting Bob using her phone. The **mapping** of digits to letters is shown in the figure below.
+
+![](https://assets.leetcode.com/uploads/2022/03/15/1200px-telephone-keypad2svg.png)
+
+In order to **add** a letter, Alice has to **press** the key of the corresponding digit `i` times, where `i` is the position of the letter in the key.
+
+*   For example, to add the letter `'s'`, Alice has to press `'7'` four times. Similarly, to add the letter `'k'`, Alice has to press `'5'` twice.
+*   Note that the digits `'0'` and `'1'` do not map to any letters, so Alice **does not** use them.
+
+However, due to an error in transmission, Bob did not receive Alice's text message but received a **string of pressed keys** instead.
+
+*   For example, when Alice sent the message `"bob"`, Bob received the string `"2266622"`.
+
+Given a string `pressedKeys` representing the string received by Bob, return _the **total number of possible text messages** Alice could have sent_.
+
+Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** pressedKeys = "22233"
+
+**Output:** 8
+
+**Explanation:** 
+
+The possible text messages Alice could have sent are: 
+
+"aaadd", "abdd", "badd", "cdd", "aaae", "abe", "bae", and "ce". 
+
+Since there are 8 possible messages, we return 8.
+
+**Example 2:**
+
+**Input:** pressedKeys = "222222222222222222222222222222222222"
+
+**Output:** 82876089
+
+**Explanation:** There are 2082876103 possible text messages Alice could have sent. 
+
+Since we need to return the answer modulo 10<sup>9</sup> + 7, we return 2082876103 % (10<sup>9</sup> + 7) = 82876089.
+
+**Constraints:**
+
+*   <code>1 <= pressedKeys.length <= 10<sup>5</sup></code>
+*   `pressedKeys` only consists of digits from `'2'` - `'9'`.
+
+## Solution
+
+```java
+@SuppressWarnings("java:S135")
+public class Solution {
+    public int countTexts(String pressedKeys) {
+        int len = pressedKeys.length();
+        long dp0 = 1L;
+        long dp1 = 0;
+        long dp2 = 0;
+        long dp3 = 0;
+        long dp4;
+        char[] keys = pressedKeys.toCharArray();
+        int base = 1000000007;
+        for (int i = 1; i < len; i++) {
+            int r = keys[i] - '0';
+            dp4 = dp3;
+            dp3 = dp2;
+            dp2 = dp1;
+            dp1 = dp0 % base;
+            dp0 = dp1;
+            dp0 += (i - 1 == 0 && keys[i] == keys[i - 1]) ? 1 : 0;
+            if (i - 1 <= 0 || keys[i] != keys[i - 1]) {
+                continue;
+            }
+            dp0 += dp2;
+            dp0 += (i - 2 == 0 && keys[i] == keys[i - 2]) ? 1 : 0;
+            if (i - 2 <= 0 || keys[i] != keys[i - 2]) {
+                continue;
+            }
+            dp0 += dp3;
+            dp0 += (i - 3 == 0 && keys[i] == keys[i - 3] && (r == 7 || r == 9)) ? 1 : 0;
+            if (i - 3 <= 0 || keys[i] != keys[i - 3] || (r != 7 && r != 9)) {
+                continue;
+            }
+            dp0 += dp4;
+        }
+
+        return (int) (dp0 % base);
+    }
+}
+```