Added tasks 1807, 1808, 1812, 1813, 1814.

Author: ThanhNIT

src/main/java/g1801_1900/s1807_evaluate_the_bracket_pairs_of_a_string/Solution.java

@@ -0,0 +1,34 @@
+package g1801_1900.s1807_evaluate_the_bracket_pairs_of_a_string;
+
+// #Medium #Array #String #Hash_Table #2022_05_03_Time_40_ms_(80.47%)_Space_79.8_MB_(96.48%)
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+    public String evaluate(String s, List<List<String>> knowledge) {
+        Map<String, String> knowledgeMapper = new HashMap<>();
+        for (List<String> pair : knowledge) {
+            knowledgeMapper.put(pair.get(0), pair.get(1));
+        }
+        StringBuilder answer = new StringBuilder();
+        int i = 0;
+        while (i < s.length()) {
+            char letter = s.charAt(i);
+            if (letter == '(') {
+                StringBuilder key = new StringBuilder();
+                letter = s.charAt(++i);
+                while (letter != ')') {
+                    key.append(letter);
+                    letter = s.charAt(++i);
+                }
+                answer.append(knowledgeMapper.getOrDefault(key.toString(), "?"));
+            } else {
+                answer.append(letter);
+            }
+            i++;
+        }
+        return answer.toString();
+    }
+}

src/main/java/g1801_1900/s1807_evaluate_the_bracket_pairs_of_a_string/readme.md

@@ -0,0 +1,63 @@
+1807\. Evaluate the Bracket Pairs of a String
+
+Medium
+
+You are given a string `s` that contains some bracket pairs, with each pair containing a **non-empty** key.
+
+*   For example, in the string `"(name)is(age)yearsold"`, there are **two** bracket pairs that contain the keys `"name"` and `"age"`.
+
+You know the values of a wide range of keys. This is represented by a 2D string array `knowledge` where each <code>knowledge[i] = [key<sub>i</sub>, value<sub>i</sub>]</code> indicates that key <code>key<sub>i</sub></code> has a value of <code>value<sub>i</sub></code>.
+
+You are tasked to evaluate **all** of the bracket pairs. When you evaluate a bracket pair that contains some key <code>key<sub>i</sub></code>, you will:
+
+*   Replace <code>key<sub>i</sub></code> and the bracket pair with the key's corresponding <code>value<sub>i</sub></code>.
+*   If you do not know the value of the key, you will replace <code>key<sub>i</sub></code> and the bracket pair with a question mark `"?"` (without the quotation marks).
+
+Each key will appear at most once in your `knowledge`. There will not be any nested brackets in `s`.
+
+Return _the resulting string after evaluating **all** of the bracket pairs._
+
+**Example 1:**
+
+**Input:** s = "(name)is(age)yearsold", knowledge = [["name","bob"],["age","two"]]
+
+**Output:** "bobistwoyearsold"
+
+**Explanation:** 
+
+The key "name" has a value of "bob", so replace "(name)" with "bob". 
+
+The key "age" has a value of "two", so replace "(age)" with "two".
+
+**Example 2:**
+
+**Input:** s = "hi(name)", knowledge = [["a","b"]]
+
+**Output:** "hi?"
+
+**Explanation:** As you do not know the value of the key "name", replace "(name)" with "?".
+
+**Example 3:**
+
+**Input:** s = "(a)(a)(a)aaa", knowledge = [["a","yes"]]
+
+**Output:** "yesyesyesaaa"
+
+**Explanation:** The same key can appear multiple times. 
+
+The key "a" has a value of "yes", so replace all occurrences of "(a)" with "yes". 
+
+Notice that the "a"s not in a bracket pair are not evaluated.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   <code>0 <= knowledge.length <= 10<sup>5</sup></code>
+*   `knowledge[i].length == 2`
+*   <code>1 <= key<sub>i</sub>.length, value<sub>i</sub>.length <= 10</code>
+*   `s` consists of lowercase English letters and round brackets `'('` and `')'`.
+*   Every open bracket `'('` in `s` will have a corresponding close bracket `')'`.
+*   The key in each bracket pair of `s` will be non-empty.
+*   There will not be any nested bracket pairs in `s`.
+*   <code>key<sub>i</sub></code> and <code>value<sub>i</sub></code> consist of lowercase English letters.
+*   Each <code>key<sub>i</sub></code> in `knowledge` is unique.

src/main/java/g1801_1900/s1808_maximize_number_of_nice_divisors/Solution.java

@@ -0,0 +1,32 @@
+package g1801_1900.s1808_maximize_number_of_nice_divisors;
+
+// #Hard #Math #Recursion #2022_05_03_Time_1_ms_(80.77%)_Space_41_MB_(42.31%)
+
+public class Solution {
+    private long modPow(long b, int e, int m) {
+        if (m == 1) {
+            return 0;
+        }
+        if (e == 0 || b == 1) {
+            return 1;
+        }
+
+        b %= m;
+
+        long r = 1;
+        while (e > 0) {
+            if ((e & 1) == 1) {
+                r = r * b % m;
+            }
+            e = e >> 1;
+            b = b * b % m;
+        }
+        return r;
+    }
+
+    public int maxNiceDivisors(int pf) {
+        int mod = 1000000007;
+        int[] st = new int[] {0, 1, 2, 3, 4, 6};
+        return pf < 5 ? pf : (int) (modPow(3, pf / 3 - 1, mod) * st[3 + pf % 3] % mod);
+    }
+}

src/main/java/g1801_1900/s1808_maximize_number_of_nice_divisors/readme.md

@@ -0,0 +1,30 @@
+1808\. Maximize Number of Nice Divisors
+
+Hard
+
+You are given a positive integer `primeFactors`. You are asked to construct a positive integer `n` that satisfies the following conditions:
+
+*   The number of prime factors of `n` (not necessarily distinct) is **at most** `primeFactors`.
+*   The number of nice divisors of `n` is maximized. Note that a divisor of `n` is **nice** if it is divisible by every prime factor of `n`. For example, if `n = 12`, then its prime factors are `[2,2,3]`, then `6` and `12` are nice divisors, while `3` and `4` are not.
+
+Return _the number of nice divisors of_ `n`. Since that number can be too large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+Note that a prime number is a natural number greater than `1` that is not a product of two smaller natural numbers. The prime factors of a number `n` is a list of prime numbers such that their product equals `n`.
+
+**Example 1:**
+
+**Input:** primeFactors = 5
+
+**Output:** 6
+
+**Explanation:** 200 is a valid value of n. It has 5 prime factors: [2,2,2,5,5], and it has 6 nice divisors: [10,20,40,50,100,200]. There is not other value of n that has at most 5 prime factors and more nice divisors.
+
+**Example 2:**
+
+**Input:** primeFactors = 8
+
+**Output:** 18
+
+**Constraints:**
+
+*   <code>1 <= primeFactors <= 10<sup>9</sup></code>

src/main/java/g1801_1900/s1812_determine_color_of_a_chessboard_square/Solution.java

@@ -0,0 +1,19 @@
+package g1801_1900.s1812_determine_color_of_a_chessboard_square;
+
+// #Easy #String #Math #2022_05_03_Time_1_ms_(49.36%)_Space_41.4_MB_(67.43%)
+
+public class Solution {
+    public boolean squareIsWhite(String coordinates) {
+        char x = coordinates.charAt(0);
+        int y = Integer.parseInt(coordinates.charAt(1) + "");
+        switch (x) {
+            case 'a':
+            case 'c':
+            case 'e':
+            case 'g':
+                return y % 2 == 0;
+            default:
+                return y % 2 != 0;
+        }
+    }
+}

src/main/java/g1801_1900/s1812_determine_color_of_a_chessboard_square/readme.md

@@ -0,0 +1,39 @@
+1812\. Determine Color of a Chessboard Square
+
+Easy
+
+You are given `coordinates`, a string that represents the coordinates of a square of the chessboard. Below is a chessboard for your reference.
+
+![](https://assets.leetcode.com/uploads/2021/02/19/screenshot-2021-02-20-at-22159-pm.png)
+
+Return `true` _if the square is white, and_ `false` _if the square is black_.
+
+The coordinate will always represent a valid chessboard square. The coordinate will always have the letter first, and the number second.
+
+**Example 1:**
+
+**Input:** coordinates = "a1"
+
+**Output:** false
+
+**Explanation:** From the chessboard above, the square with coordinates "a1" is black, so return false.
+
+**Example 2:**
+
+**Input:** coordinates = "h3"
+
+**Output:** true
+
+**Explanation:** From the chessboard above, the square with coordinates "h3" is white, so return true.
+
+**Example 3:**
+
+**Input:** coordinates = "c7"
+
+**Output:** false
+
+**Constraints:**
+
+*   `coordinates.length == 2`
+*   `'a' <= coordinates[0] <= 'h'`
+*   `'1' <= coordinates[1] <= '8'`

src/main/java/g1801_1900/s1813_sentence_similarity_iii/Solution.java

@@ -0,0 +1,51 @@
+package g1801_1900.s1813_sentence_similarity_iii;
+
+// #Medium #Array #String #Two_Pointers #2022_05_03_Time_3_ms_(40.12%)_Space_42.3_MB_(43.02%)
+
+public class Solution {
+    public boolean areSentencesSimilar(String sentence1, String sentence2) {
+        String shorter = sentence1.length() < sentence2.length() ? sentence1 : sentence2;
+        String longer = shorter.equals(sentence1) ? sentence2 : sentence1;
+        String[] shortWords = shorter.split(" ");
+        String[] longWords = longer.split(" ");
+        int breaks = 0;
+        int j = 0;
+        int i = 0;
+        while (i < shortWords.length && j < longWords.length) {
+            if (shortWords[i].equals(longWords[j])) {
+                j++;
+                i++;
+            } else {
+                breaks++;
+                if (breaks > 1) {
+                    break;
+                }
+                while (j < longWords.length && !longWords[j].equals(shortWords[i])) {
+                    j++;
+                }
+            }
+        }
+        if ((breaks == 1 && i == shortWords.length && j == longWords.length)
+                || (i == shortWords.length && breaks == 0)) {
+            return true;
+        }
+        i = shortWords.length - 1;
+        j = longWords.length - 1;
+        breaks = 0;
+        while (i >= 0 && j >= 0) {
+            if (shortWords[i].equals(longWords[j])) {
+                i--;
+                j--;
+            } else {
+                breaks++;
+                if (breaks > 1) {
+                    return false;
+                }
+                while (j >= 0 && !longWords[j].equals(shortWords[i])) {
+                    j--;
+                }
+            }
+        }
+        return (breaks == 1 && i == -1 && j == -1) || (breaks == 0 && i == -1);
+    }
+}

src/main/java/g1801_1900/s1813_sentence_similarity_iii/readme.md

@@ -0,0 +1,39 @@
+1813\. Sentence Similarity III
+
+Medium
+
+A sentence is a list of words that are separated by a single space with no leading or trailing spaces. For example, `"Hello World"`, `"HELLO"`, `"hello world hello world"` are all sentences. Words consist of **only** uppercase and lowercase English letters.
+
+Two sentences `sentence1` and `sentence2` are **similar** if it is possible to insert an arbitrary sentence **(possibly empty)** inside one of these sentences such that the two sentences become equal. For example, `sentence1 = "Hello my name is Jane"` and `sentence2 = "Hello Jane"` can be made equal by inserting `"my name is"` between `"Hello"` and `"Jane"` in `sentence2`.
+
+Given two sentences `sentence1` and `sentence2`, return `true` _if_ `sentence1` _and_ `sentence2` _are similar._ Otherwise, return `false`.
+
+**Example 1:**
+
+**Input:** sentence1 = "My name is Haley", sentence2 = "My Haley"
+
+**Output:** true
+
+**Explanation:** sentence2 can be turned to sentence1 by inserting "name is" between "My" and "Haley".
+
+**Example 2:**
+
+**Input:** sentence1 = "of", sentence2 = "A lot of words"
+
+**Output:** false
+
+**Explanation:** No single sentence can be inserted inside one of the sentences to make it equal to the other.
+
+**Example 3:**
+
+**Input:** sentence1 = "Eating right now", sentence2 = "Eating"
+
+**Output:** true
+
+**Explanation:** sentence2 can be turned to sentence1 by inserting "right now" at the end of the sentence.
+
+**Constraints:**
+
+*   `1 <= sentence1.length, sentence2.length <= 100`
+*   `sentence1` and `sentence2` consist of lowercase and uppercase English letters and spaces.
+*   The words in `sentence1` and `sentence2` are separated by a single space.

src/main/java/g1801_1900/s1814_count_nice_pairs_in_an_array/Solution.java

@@ -0,0 +1,32 @@
+package g1801_1900.s1814_count_nice_pairs_in_an_array;
+
+// #Medium #Array #Hash_Table #Math #Counting #2022_05_03_Time_47_ms_(83.12%)_Space_77.6_MB_(28.57%)
+
+import java.util.HashMap;
+
+public class Solution {
+
+    private int rev(int n) {
+        int r = 0;
+        while (n > 0) {
+            r = r * 10 + n % 10;
+            n = n / 10;
+        }
+        return r;
+    }
+
+    public int countNicePairs(int[] nums) {
+        HashMap<Integer, Integer> revMap = new HashMap<>();
+        int cnt = 0;
+        for (int num : nums) {
+            int lhs = num - rev(num);
+            int prevCnt = revMap.getOrDefault(lhs, 0);
+            cnt += prevCnt;
+            int mod = 1000000007;
+            cnt = cnt % mod;
+            revMap.put(lhs, prevCnt + 1);
+        }
+
+        return cnt;
+    }
+}

src/main/java/g1801_1900/s1814_count_nice_pairs_in_an_array/readme.md

@@ -0,0 +1,33 @@
+1814\. Count Nice Pairs in an Array
+
+Medium
+
+You are given an array `nums` that consists of non-negative integers. Let us define `rev(x)` as the reverse of the non-negative integer `x`. For example, `rev(123) = 321`, and `rev(120) = 21`. A pair of indices `(i, j)` is **nice** if it satisfies all of the following conditions:
+
+*   `0 <= i < j < nums.length`
+*   `nums[i] + rev(nums[j]) == nums[j] + rev(nums[i])`
+
+Return _the number of nice pairs of indices_. Since that number can be too large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** nums = [42,11,1,97]
+
+**Output:** 2
+
+**Explanation:** The two pairs are: 
+
+- (0,3) : 42 + rev(97) = 42 + 79 = 121, 97 + rev(42) = 97 + 24 = 121. 
+
+- (1,2) : 11 + rev(1) = 11 + 1 = 12, 1 + rev(11) = 1 + 11 = 12.
+
+**Example 2:**
+
+**Input:** nums = [13,10,35,24,76]
+
+**Output:** 4
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>9</sup></code>