Added tasks 2060, 2062, 2063, 2064, 2065.

Author: ThanhNIT

src/main/java/g2001_2100/s2060_check_if_an_original_string_exists_given_two_encoded_strings/Solution.java

@@ -0,0 +1,113 @@
+package g2001_2100.s2060_check_if_an_original_string_exists_given_two_encoded_strings;
+
+// #Hard #String #Dynamic_Programming #2022_05_29_Time_354_ms_(69.39%)_Space_209.4_MB_(51.21%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    private boolean stringMatched = false;
+    private String s1;
+    private String s2;
+
+    static class Key {
+        int i1;
+        int i2;
+
+        Key(int i1, int i2) {
+            this.i1 = i1;
+            this.i2 = i2;
+        }
+    }
+
+    private Boolean[][][] memo;
+
+    public boolean possiblyEquals(String s1, String s2) {
+
+        this.s1 = s1;
+        this.s2 = s2;
+        memo = new Boolean[s1.length() + 1][s2.length() + 1][2000];
+        dfs(0, 0, 0);
+        return stringMatched;
+    }
+
+    private void dfs(int i1, int i2, int diff) {
+        if (stringMatched) {
+            return;
+        }
+        if (i1 == s1.length() && i2 == s2.length()) {
+            if (diff == 0) {
+                stringMatched = true;
+            }
+            return;
+        }
+        if (i1 == s1.length() && diff <= 0) {
+            return;
+        }
+        if (i2 == s2.length() && diff >= 0) {
+            return;
+        }
+        if (memo[i1][i2][diff + 999] != null) {
+            stringMatched = memo[i1][i2][diff + 999];
+            return;
+        }
+
+        List<int[]> indexNums1 = new ArrayList<>();
+        int num1 = 0;
+        int x1 = i1;
+        while (x1 < s1.length() && Character.isDigit(s1.charAt(x1))) {
+            num1 = num1 * 10 + (s1.charAt(x1) - '0');
+            indexNums1.add(new int[] {x1, num1});
+            x1++;
+        }
+
+        List<int[]> indexNums2 = new ArrayList<>();
+        int num2 = 0;
+        int x2 = i2;
+        while (x2 < s2.length() && Character.isDigit(s2.charAt(x2))) {
+            num2 = num2 * 10 + (s2.charAt(x2) - '0');
+            indexNums2.add(new int[] {x2, num2});
+            x2++;
+        }
+
+        if (diff == 0) {
+            char c1 = s1.charAt(i1);
+            char c2 = s2.charAt(i2);
+            if (Character.isLetter(c1) && Character.isLetter(c2)) {
+                if (c1 != c2) {
+                    return;
+                }
+                dfs(i1 + 1, i2 + 1, diff);
+                return;
+            } else {
+                if (!indexNums1.isEmpty()) {
+                    for (int[] num1Item : indexNums1) {
+                        dfs(num1Item[0] + 1, i2, diff + num1Item[1]);
+                    }
+                } else {
+                    for (int[] num2Item : indexNums2) {
+                        dfs(i1, num2Item[0] + 1, diff - num2Item[1]);
+                    }
+                }
+            }
+        } else if (diff > 0) {
+            if (Character.isLetter(s2.charAt(i2))) {
+                dfs(i1, i2 + 1, diff - 1);
+            } else {
+                for (int[] num2Item : indexNums2) {
+                    dfs(i1, num2Item[0] + 1, diff - num2Item[1]);
+                }
+            }
+        } else {
+            if (Character.isLetter(s1.charAt(i1))) {
+                dfs(i1 + 1, i2, diff + 1);
+            } else {
+                for (int[] num1Item : indexNums1) {
+                    dfs(num1Item[0] + 1, i2, diff + num1Item[1]);
+                }
+            }
+        }
+
+        memo[i1][i2][diff + 999] = stringMatched;
+    }
+}

src/main/java/g2001_2100/s2060_check_if_an_original_string_exists_given_two_encoded_strings/readme.md

@@ -0,0 +1,85 @@
+2060\. Check if an Original String Exists Given Two Encoded Strings
+
+Hard
+
+An original string, consisting of lowercase English letters, can be encoded by the following steps:
+
+*   Arbitrarily **split** it into a **sequence** of some number of **non-empty** substrings.
+*   Arbitrarily choose some elements (possibly none) of the sequence, and **replace** each with **its length** (as a numeric string).
+*   **Concatenate** the sequence as the encoded string.
+
+For example, **one way** to encode an original string `"abcdefghijklmnop"` might be:
+
+*   Split it as a sequence: `["ab", "cdefghijklmn", "o", "p"]`.
+*   Choose the second and third elements to be replaced by their lengths, respectively. The sequence becomes `["ab", "12", "1", "p"]`.
+*   Concatenate the elements of the sequence to get the encoded string: `"ab121p"`.
+
+Given two encoded strings `s1` and `s2`, consisting of lowercase English letters and digits `1-9` (inclusive), return `true` _if there exists an original string that could be encoded as **both**_ `s1` _and_ `s2`_. Otherwise, return_ `false`.
+
+**Note**: The test cases are generated such that the number of consecutive digits in `s1` and `s2` does not exceed `3`.
+
+**Example 1:**
+
+**Input:** s1 = "internationalization", s2 = "i18n"
+
+**Output:** true
+
+**Explanation:** It is possible that "internationalization" was the original string. 
+
+- "internationalization" 
+  
+    -> Split: ["internationalization"] 
+  
+    -> Do not replace any element 
+    
+    -> Concatenate: "internationalization", which is s1. 
+    
+- "internationalization" 
+  
+    -> Split: ["i", "nternationalizatio", "n"]
+  
+    -> Replace: ["i", "18", "n"] 
+  
+    -> Concatenate: "i18n", which is s2
+
+**Example 2:**
+
+**Input:** s1 = "l123e", s2 = "44"
+
+**Output:** true
+
+**Explanation:** It is possible that "leetcode" was the original string. 
+
+- "leetcode" 
+  
+    -> Split: ["l", "e", "et", "cod", "e"] 
+  
+    -> Replace: ["l", "1", "2", "3", "e"] 
+  
+    -> Concatenate: "l123e", which is s1. 
+    
+- "leetcode" 
+  
+    -> Split: ["leet", "code"] 
+  
+    -> Replace: ["4", "4"] 
+  
+    -> Concatenate: "44", which is s2.
+
+**Example 3:**
+
+**Input:** s1 = "a5b", s2 = "c5b"
+
+**Output:** false
+
+**Explanation:** It is impossible. 
+
+- The original string encoded as s1 must start with the letter 'a'. 
+
+- The original string encoded as s2 must start with the letter 'c'.
+
+**Constraints:**
+
+*   `1 <= s1.length, s2.length <= 40`
+*   `s1` and `s2` consist of digits `1-9` (inclusive), and lowercase English letters only.
+*   The number of consecutive digits in `s1` and `s2` does not exceed `3`.

src/main/java/g2001_2100/s2062_count_vowel_substrings_of_a_string/Solution.java

@@ -0,0 +1,32 @@
+package g2001_2100.s2062_count_vowel_substrings_of_a_string;
+
+// #Easy #String #Hash_Table #2022_05_29_Time_34_ms_(23.83%)_Space_41.9_MB_(71.28%)
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+    public int countVowelSubstrings(String word) {
+        int count = 0;
+        Set<Character> vowels = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u'));
+        Set<Character> window = new HashSet<>();
+        for (int i = 0; i < word.length(); i++) {
+            window.clear();
+            if (vowels.contains(word.charAt(i))) {
+                window.add(word.charAt(i));
+                for (int j = i + 1; j < word.length(); j++) {
+                    if (!vowels.contains(word.charAt(j))) {
+                        break;
+                    } else {
+                        window.add(word.charAt(j));
+                        if (window.size() == 5) {
+                            count++;
+                        }
+                    }
+                }
+            }
+        }
+        return count;
+    }
+}

src/main/java/g2001_2100/s2062_count_vowel_substrings_of_a_string/readme.md

@@ -0,0 +1,56 @@
+2062\. Count Vowel Substrings of a String
+
+Easy
+
+A **substring** is a contiguous (non-empty) sequence of characters within a string.
+
+A **vowel substring** is a substring that **only** consists of vowels (`'a'`, `'e'`, `'i'`, `'o'`, and `'u'`) and has **all five** vowels present in it.
+
+Given a string `word`, return _the number of **vowel substrings** in_ `word`.
+
+**Example 1:**
+
+**Input:** word = "aeiouu"
+
+**Output:** 2
+
+**Explanation:** The vowel substrings of word are as follows (underlined): 
+
+- "**aeiou**u" 
+
+- "**aeiouu**"
+
+**Example 2:**
+
+**Input:** word = "unicornarihan"
+
+**Output:** 0
+
+**Explanation:** Not all 5 vowels are present, so there are no vowel substrings.
+
+**Example 3:**
+
+**Input:** word = "cuaieuouac"
+
+**Output:** 7
+
+**Explanation:** The vowel substrings of word are as follows (underlined): 
+
+- "c**uaieuo**uac" 
+
+- "c**uaieuou**ac" 
+
+- "c**uaieuoua**c" 
+
+- "cu**aieuo**uac" 
+
+- "cu**aieuou**ac" 
+
+- "cu**aieuoua**c" 
+
+- "cua**ieuoua**c"
+
+**Constraints:**
+
+*   `1 <= word.length <= 100`
+*   `word` consists of lowercase English letters only.

src/main/java/g2001_2100/s2063_vowels_of_all_substrings/Solution.java

@@ -0,0 +1,21 @@
+package g2001_2100.s2063_vowels_of_all_substrings;
+
+// #Medium #String #Dynamic_Programming #Math #Combinatorics
+// #2022_05_29_Time_21_ms_(34.49%)_Space_48.9_MB_(68.06%)
+
+public class Solution {
+    public long countVowels(String word) {
+        long ans = 0;
+        for (int i = 0; i < word.length(); i++) {
+            if (isVowel(word.charAt(i))) {
+                long right = word.length() - (long) i - 1;
+                ans += ((long) i + 1) * (right + 1);
+            }
+        }
+        return ans;
+    }
+
+    private boolean isVowel(char ch) {
+        return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u';
+    }
+}

src/main/java/g2001_2100/s2063_vowels_of_all_substrings/readme.md

@@ -0,0 +1,52 @@
+2063\. Vowels of All Substrings
+
+Medium
+
+Given a string `word`, return _the **sum of the number of vowels** (_`'a'`, `'e'`_,_ `'i'`_,_ `'o'`_, and_ `'u'`_)_ _in every substring of_ `word`.
+
+A **substring** is a contiguous (non-empty) sequence of characters within a string.
+
+**Note:** Due to the large constraints, the answer may not fit in a signed 32-bit integer. Please be careful during the calculations.
+
+**Example 1:**
+
+**Input:** word = "aba"
+
+**Output:** 6
+
+**Explanation:** All possible substrings are: "a", "ab", "aba", "b", "ba", and "a". 
+
+- "b" has 0 vowels in it 
+
+- "a", "ab", "ba", and "a" have 1 vowel each 
+
+- "aba" has 2 vowels in it 
+  
+Hence, the total sum of vowels = 0 + 1 + 1 + 1 + 1 + 2 = 6.
+
+**Example 2:**
+
+**Input:** word = "abc"
+
+**Output:** 3
+
+**Explanation:** All possible substrings are: "a", "ab", "abc", "b", "bc", and "c". 
+
+- "a", "ab", and "abc" have 1 vowel each 
+
+- "b", "bc", and "c" have 0 vowels each 
+  
+Hence, the total sum of vowels = 1 + 1 + 1 + 0 + 0 + 0 = 3.
+
+**Example 3:**
+
+**Input:** word = "ltcd"
+
+**Output:** 0
+
+**Explanation:** There are no vowels in any substring of "ltcd".
+
+**Constraints:**
+
+*   <code>1 <= word.length <= 10<sup>5</sup></code>
+*   `word` consists of lowercase English letters.