Added tasks 1952, 1953, 1954, 1955, 1957.

Author: ThanhNIT

src/main/java/g1901_2000/s1952_three_divisors/Solution.java

@@ -0,0 +1,15 @@
+package g1901_2000.s1952_three_divisors;
+
+// #Easy #Math #2022_05_18_Time_3_ms_(6.76%)_Space_39.9_MB_(72.52%)
+
+public class Solution {
+    public boolean isThree(int n) {
+        int divisors = 0;
+        for (int i = 1; i <= n; i++) {
+            if (n % i == 0) {
+                divisors++;
+            }
+        }
+        return divisors == 3;
+    }
+}

src/main/java/g1901_2000/s1952_three_divisors/readme.md

@@ -0,0 +1,23 @@
+1952\. Three Divisors
+
+Easy
+
+Given an integer `n`, return `true` _if_ `n` _has **exactly three positive divisors**. Otherwise, return_ `false`.
+
+An integer `m` is a **divisor** of `n` if there exists an integer `k` such that `n = k * m`.
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** false **Explantion:** 2 has only two divisors: 1 and 2.
+
+**Example 2:**
+
+**Input:** n = 4
+
+**Output:** true **Explantion:** 4 has three divisors: 1, 2, and 4.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>4</sup></code>

src/main/java/g1901_2000/s1953_maximum_number_of_weeks_for_which_you_can_work/Solution.java

@@ -0,0 +1,15 @@
+package g1901_2000.s1953_maximum_number_of_weeks_for_which_you_can_work;
+
+// #Medium #Array #Greedy #2022_05_18_Time_4_ms_(40.93%)_Space_77.6_MB_(67.51%)
+
+public class Solution {
+    public long numberOfWeeks(int[] milestones) {
+        long sum = 0;
+        long max = 0;
+        for (int m : milestones) {
+            sum += m;
+            max = Math.max(max, m);
+        }
+        return sum - max + 1 >= max ? sum : 1 + 2 * (sum - max);
+    }
+}

src/main/java/g1901_2000/s1953_maximum_number_of_weeks_for_which_you_can_work/readme.md

@@ -0,0 +1,66 @@
+1953\. Maximum Number of Weeks for Which You Can Work
+
+Medium
+
+There are `n` projects numbered from `0` to `n - 1`. You are given an integer array `milestones` where each `milestones[i]` denotes the number of milestones the <code>i<sup>th</sup></code> project has.
+
+You can work on the projects following these two rules:
+
+*   Every week, you will finish **exactly one** milestone of **one** project. You **must** work every week.
+*   You **cannot** work on two milestones from the same project for two **consecutive** weeks.
+
+Once all the milestones of all the projects are finished, or if the only milestones that you can work on will cause you to violate the above rules, you will **stop working**. Note that you may not be able to finish every project's milestones due to these constraints.
+
+Return _the **maximum** number of weeks you would be able to work on the projects without violating the rules mentioned above_.
+
+**Example 1:**
+
+**Input:** milestones = [1,2,3]
+
+**Output:** 6
+
+**Explanation:** One possible scenario is: 
+
+- During the 1<sup>st</sup> week, you will work on a milestone of project 0. 
+
+- During the 2<sup>nd</sup> week, you will work on a milestone of project 2. 
+
+- During the 3<sup>rd</sup> week, you will work on a milestone of project 1. 
+
+- During the 4<sup>th</sup> week, you will work on a milestone of project 2. 
+
+- During the 5<sup>th</sup> week, you will work on a milestone of project 1. 
+
+- During the 6<sup>th</sup> week, you will work on a milestone of project 2. 
+  
+The total number of weeks is 6.
+
+**Example 2:**
+
+**Input:** milestones = [5,2,1]
+
+**Output:** 7
+
+**Explanation:** One possible scenario is: 
+
+- During the 1<sup>st</sup> week, you will work on a milestone of project 0. 
+
+- During the 2<sup>nd</sup> week, you will work on a milestone of project 1. 
+
+- During the 3<sup>rd</sup> week, you will work on a milestone of project 0. 
+
+- During the 4<sup>th</sup> week, you will work on a milestone of project 1. 
+
+- During the 5<sup>th</sup> week, you will work on a milestone of project 0. 
+
+- During the 6<sup>th</sup> week, you will work on a milestone of project 2. 
+
+- During the 7<sup>th</sup> week, you will work on a milestone of project 0. 
+  
+The total number of weeks is 7. Note that you cannot work on the last milestone of project 0 on 8<sup>th</sup> week because it would violate the rules. Thus, one milestone in project 0 will remain unfinished.
+
+**Constraints:**
+
+*   `n == milestones.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= milestones[i] <= 10<sup>9</sup></code>

src/main/java/g1901_2000/s1954_minimum_garden_perimeter_to_collect_enough_apples/Solution.java

@@ -0,0 +1,31 @@
+package g1901_2000.s1954_minimum_garden_perimeter_to_collect_enough_apples;
+
+// #Medium #Math #Binary_Search #2022_05_18_Time_2_ms_(59.57%)_Space_40.7_MB_(69.15%)
+
+public class Solution {
+    public long minimumPerimeter(long neededApples) {
+        long l = 1;
+        long r = 1000000;
+        long res = l;
+
+        while (l <= r) {
+            long m = l + (r - l) / 2;
+            boolean isPossible = check(m, neededApples);
+
+            if (isPossible) {
+                res = m;
+                r = m - 1;
+            } else {
+                l = m + 1;
+            }
+        }
+        return res * 8;
+    }
+
+    private boolean check(long len, long neededApples) {
+        long sum = len * (len + 1) / 2;
+        long applesPerQuadrant = 2 * len * sum;
+        long totalCount = 4 * sum + 4 * applesPerQuadrant;
+        return (totalCount >= neededApples);
+    }
+}

src/main/java/g1901_2000/s1954_minimum_garden_perimeter_to_collect_enough_apples/readme.md

@@ -0,0 +1,40 @@
+1954\. Minimum Garden Perimeter to Collect Enough Apples
+
+Medium
+
+In a garden represented as an infinite 2D grid, there is an apple tree planted at **every** integer coordinate. The apple tree planted at an integer coordinate `(i, j)` has `|i| + |j|` apples growing on it.
+
+You will buy an axis-aligned **square plot** of land that is centered at `(0, 0)`.
+
+Given an integer `neededApples`, return _the **minimum perimeter** of a plot such that **at least**_ `neededApples` _apples are **inside or on** the perimeter of that plot_.
+
+The value of `|x|` is defined as:
+
+*   `x` if `x >= 0`
+*   `-x` if `x < 0`
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/08/30/1527_example_1_2.png)
+
+**Input:** neededApples = 1
+
+**Output:** 8
+
+**Explanation:** A square plot of side length 1 does not contain any apples. However, a square plot of side length 2 has 12 apples inside (as depicted in the image above). The perimeter is 2 \* 4 = 8.
+
+**Example 2:**
+
+**Input:** neededApples = 13
+
+**Output:** 16
+
+**Example 3:**
+
+**Input:** neededApples = 1000000000
+
+**Output:** 5040
+
+**Constraints:**
+
+*   <code>1 <= neededApples <= 10<sup>15</sup></code>

src/main/java/g1901_2000/s1955_count_number_of_special_subsequences/Solution.java

@@ -0,0 +1,16 @@
+package g1901_2000.s1955_count_number_of_special_subsequences;
+
+// #Hard #Array #Dynamic_Programming #2022_05_18_Time_22_ms_(80.65%)_Space_121_MB_(27.42%)
+
+public class Solution {
+    public int countSpecialSubsequences(int[] nums) {
+        int mod = 1000000007;
+        int[] dp = new int[] {1, 0, 0, 0};
+
+        for (int n : nums) {
+            dp[n + 1] = (dp[n] + 2 * dp[n + 1] % mod) % mod;
+        }
+
+        return dp[3];
+    }
+}

src/main/java/g1901_2000/s1955_count_number_of_special_subsequences/readme.md

@@ -0,0 +1,55 @@
+1955\. Count Number of Special Subsequences
+
+Hard
+
+A sequence is **special** if it consists of a **positive** number of `0`s, followed by a **positive** number of `1`s, then a **positive** number of `2`s.
+
+*   For example, `[0,1,2]` and `[0,0,1,1,1,2]` are special.
+*   In contrast, `[2,1,0]`, `[1]`, and `[0,1,2,0]` are not special.
+
+Given an array `nums` (consisting of **only** integers `0`, `1`, and `2`), return _the **number of different subsequences** that are special_. Since the answer may be very large, **return it modulo** <code>10<sup>9</sup> + 7</code>.
+
+A **subsequence** of an array is a sequence that can be derived from the array by deleting some or no elements without changing the order of the remaining elements. Two subsequences are **different** if the **set of indices** chosen are different.
+
+**Example 1:**
+
+**Input:** nums = [0,1,2,2]
+
+**Output:** 3
+
+**Explanation:** The special subsequences are bolded [**0**,**1**,**2**,2], [**0**,**1**,2,**2**], and [**0**,**1**,**2**,**2**].
+
+**Example 2:**
+
+**Input:** nums = [2,2,0,0]
+
+**Output:** 0
+
+**Explanation:** There are no special subsequences in [2,2,0,0].
+
+**Example 3:**
+
+**Input:** nums = [0,1,2,0,1,2]
+
+**Output:** 7
+
+**Explanation:** The special subsequences are bolded: 
+
+- [**0**,**1**,**2**,0,1,2] 
+
+- [**0**,**1**,2,0,1,**2**] 
+
+- [**0**,**1**,**2**,0,1,**2**] 
+
+- [**0**,**1**,2,0,**1**,**2**] 
+
+- [**0**,1,2,**0**,**1**,**2**] 
+
+- [**0**,1,2,0,**1**,**2**] 
+
+- [0,1,2,**0**,**1**,**2**]
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   `0 <= nums[i] <= 2`

src/main/java/g1901_2000/s1957_delete_characters_to_make_fancy_string/Solution.java

@@ -0,0 +1,23 @@
+package g1901_2000.s1957_delete_characters_to_make_fancy_string;
+
+// #Easy #String #2022_05_18_Time_54_ms_(52.94%)_Space_67.8_MB_(72.35%)
+
+public class Solution {
+    public String makeFancyString(String s) {
+        StringBuilder ans = new StringBuilder();
+        int c = 1;
+        ans.append(s.charAt(0));
+        for (int i = 1; i < s.length(); i++) {
+            if (s.charAt(i) == s.charAt(i - 1)) {
+                c++;
+            } else {
+                c = 1;
+            }
+            if (c < 3) {
+                ans.append(s.charAt(i));
+            }
+        }
+
+        return ans.toString();
+    }
+}

src/main/java/g1901_2000/s1957_delete_characters_to_make_fancy_string/readme.md

@@ -0,0 +1,48 @@
+1957\. Delete Characters to Make Fancy String
+
+Easy
+
+A **fancy string** is a string where no **three** **consecutive** characters are equal.
+
+Given a string `s`, delete the **minimum** possible number of characters from `s` to make it **fancy**.
+
+Return _the final string after the deletion_. It can be shown that the answer will always be **unique**.
+
+**Example 1:**
+
+**Input:** s = "leeetcode"
+
+**Output:** "leetcode"
+
+**Explanation:** 
+
+Remove an 'e' from the first group of 'e's to create "leetcode". 
+
+No three consecutive characters are equal, so return "leetcode".
+
+**Example 2:**
+
+**Input:** s = "aaabaaaa"
+
+**Output:** "aabaa"
+
+**Explanation:** 
+
+Remove an 'a' from the first group of 'a's to create "aabaaaa". 
+
+Remove two 'a's from the second group of 'a's to create "aabaa".
+
+No three consecutive characters are equal, so return "aabaa".
+
+**Example 3:**
+
+**Input:** s = "aab"
+
+**Output:** "aab"
+
+**Explanation:** No three consecutive characters are equal, so return "aab".
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists only of lowercase English letters.

src/test/java/g1901_2000/s1952_three_divisors/SolutionTest.java

@@ -0,0 +1,18 @@
+package g1901_2000.s1952_three_divisors;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void isThree() {
+        assertThat(new Solution().isThree(2), equalTo(false));
+    }
+
+    @Test
+    void isThree2() {
+        assertThat(new Solution().isThree(4), equalTo(true));
+    }
+}

src/test/java/g1901_2000/s1953_maximum_number_of_weeks_for_which_you_can_work/SolutionTest.java

@@ -0,0 +1,18 @@
+package g1901_2000.s1953_maximum_number_of_weeks_for_which_you_can_work;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void numberOfWeeks() {
+        assertThat(new Solution().numberOfWeeks(new int[] {1, 2, 3}), equalTo(6L));
+    }
+
+    @Test
+    void numberOfWeeks2() {
+        assertThat(new Solution().numberOfWeeks(new int[] {5, 2, 1}), equalTo(7L));
+    }
+}