Added tasks 1935, 1936.

Author: ThanhNIT

src/main/java/g1901_2000/s1935_maximum_number_of_words_you_can_type/Solution.java

@@ -0,0 +1,23 @@
+package g1901_2000.s1935_maximum_number_of_words_you_can_type;
+
+// #Easy #String #Hash_Table #2022_05_15_Time_2_ms_(95.06%)_Space_42.6_MB_(61.20%)
+
+public class Solution {
+    public int canBeTypedWords(String text, String brokenLetters) {
+        String[] words = text.split(" ");
+        int count = 0;
+        for (String word : words) {
+            boolean broken = false;
+            for (char c : word.toCharArray()) {
+                if (brokenLetters.indexOf(c) != -1) {
+                    broken = true;
+                    break;
+                }
+            }
+            if (!broken) {
+                count++;
+            }
+        }
+        return count;
+    }
+}

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

@@ -0,0 +1,39 @@
+1935\. Maximum Number of Words You Can Type
+
+Easy
+
+There is a malfunctioning keyboard where some letter keys do not work. All other keys on the keyboard work properly.
+
+Given a string `text` of words separated by a single space (no leading or trailing spaces) and a string `brokenLetters` of all **distinct** letter keys that are broken, return _the **number of words** in_ `text` _you can fully type using this keyboard_.
+
+**Example 1:**
+
+**Input:** text = "hello world", brokenLetters = "ad"
+
+**Output:** 1
+
+**Explanation:** We cannot type "world" because the 'd' key is broken.
+
+**Example 2:**
+
+**Input:** text = "leet code", brokenLetters = "lt"
+
+**Output:** 1
+
+**Explanation:** We cannot type "leet" because the 'l' and 't' keys are broken.
+
+**Example 3:**
+
+**Input:** text = "leet code", brokenLetters = "e"
+
+**Output:** 0
+
+**Explanation:** We cannot type either word because the 'e' key is broken.
+
+**Constraints:**
+
+*   <code>1 <= text.length <= 10<sup>4</sup></code>
+*   `0 <= brokenLetters.length <= 26`
+*   `text` consists of words separated by a single space without any leading or trailing spaces.
+*   Each word only consists of lowercase English letters.
+*   `brokenLetters` consists of **distinct** lowercase English letters.

src/main/java/g1901_2000/s1936_add_minimum_number_of_rungs/Solution.java

@@ -0,0 +1,22 @@
+package g1901_2000.s1936_add_minimum_number_of_rungs;
+
+// #Medium #Array #Greedy #2022_05_15_Time_1_ms_(100.00%)_Space_54_MB_(89.37%)
+
+public class Solution {
+    public int addRungs(int[] rungs, int dist) {
+        int addons = 0;
+        int currentHeight = 0;
+        for (int i = 0; i < rungs.length; ) {
+            int nextRung = rungs[i];
+            if (nextRung - currentHeight <= dist) {
+                currentHeight = nextRung;
+                i++;
+            } else {
+                int adds = (nextRung - currentHeight - 1) / dist;
+                addons += adds;
+                currentHeight += dist * adds;
+            }
+        }
+        return addons;
+    }
+}

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

@@ -0,0 +1,52 @@
+1936\. Add Minimum Number of Rungs
+
+Medium
+
+You are given a **strictly increasing** integer array `rungs` that represents the **height** of rungs on a ladder. You are currently on the **floor** at height `0`, and you want to reach the last rung.
+
+You are also given an integer `dist`. You can only climb to the next highest rung if the distance between where you are currently at (the floor or on a rung) and the next rung is **at most** `dist`. You are able to insert rungs at any positive **integer** height if a rung is not already there.
+
+Return _the **minimum** number of rungs that must be added to the ladder in order for you to climb to the last rung._
+
+**Example 1:**
+
+**Input:** rungs = [1,3,5,10], dist = 2
+
+**Output:** 2
+
+**Explanation:** 
+
+You currently cannot reach the last rung. 
+
+Add rungs at heights 7 and 8 to climb this ladder. 
+
+The ladder will now have rungs at [1,3,5,7,8,10].
+
+**Example 2:**
+
+**Input:** rungs = [3,6,8,10], dist = 3
+
+**Output:** 0
+
+**Explanation:** This ladder can be climbed without adding additional rungs.
+
+**Example 3:**
+
+**Input:** rungs = [3,4,6,7], dist = 2
+
+**Output:** 1
+
+**Explanation:** 
+
+You currently cannot reach the first rung from the ground. 
+
+Add a rung at height 1 to climb this ladder. 
+
+The ladder will now have rungs at [1,3,4,6,7].
+
+**Constraints:**
+
+*   <code>1 <= rungs.length <= 10<sup>5</sup></code>
+*   <code>1 <= rungs[i] <= 10<sup>9</sup></code>
+*   <code>1 <= dist <= 10<sup>9</sup></code>
+*   `rungs` is **strictly increasing**.

src/test/java/g1901_2000/s1935_maximum_number_of_words_you_can_type/SolutionTest.java

@@ -0,0 +1,23 @@
+package g1901_2000.s1935_maximum_number_of_words_you_can_type;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void canBeTypedWords() {
+        assertThat(new Solution().canBeTypedWords("hello world", "ad"), equalTo(1));
+    }
+
+    @Test
+    void canBeTypedWords2() {
+        assertThat(new Solution().canBeTypedWords("leet code", "lt"), equalTo(1));
+    }
+
+    @Test
+    void canBeTypedWords3() {
+        assertThat(new Solution().canBeTypedWords("leet code", "e"), equalTo(0));
+    }
+}

src/test/java/g1901_2000/s1936_add_minimum_number_of_rungs/SolutionTest.java

@@ -0,0 +1,18 @@
+package g1901_2000.s1936_add_minimum_number_of_rungs;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void addRungs() {
+        assertThat(new Solution().addRungs(new int[] {3, 6, 8, 10}, 3), equalTo(0));
+    }
+
+    @Test
+    void addRungs2() {
+        assertThat(new Solution().addRungs(new int[] {3, 4, 6, 7}, 2), equalTo(1));
+    }
+}