Added tasks 1047, 1048.

Author: javadev

src/main/java/g1001_1100/s1047_remove_all_adjacent_duplicates_in_string/Solution.java

@@ -0,0 +1,26 @@
+package g1001_1100.s1047_remove_all_adjacent_duplicates_in_string;
+
+// #Easy #String #Stack #2022_02_28_Time_3_ms_(99.99%)_Space_42.7_MB_(84.52%)
+
+public class Solution {
+    public String removeDuplicates(String s) {
+        if (s.length() == 1) {
+            return s;
+        }
+        char[] array = s.toCharArray();
+        int length = array.length;
+        int fast = 0;
+        int slow = 0;
+        while (fast < length) {
+            if (slow == 0 || array[fast] != array[slow - 1]) {
+                array[slow++] = array[fast++];
+            } else {
+                if (array[fast] == array[slow - 1]) {
+                    fast++;
+                }
+                slow--;
+            }
+        }
+        return new String(array, 0, slow);
+    }
+}

src/main/java/g1001_1100/s1047_remove_all_adjacent_duplicates_in_string/readme.md

@@ -0,0 +1,32 @@
+1047\. Remove All Adjacent Duplicates In String
+
+Easy
+
+You are given a string `s` consisting of lowercase English letters. A **duplicate removal** consists of choosing two **adjacent** and **equal** letters and removing them.
+
+We repeatedly make **duplicate removals** on `s` until we no longer can.
+
+Return _the final string after all such duplicate removals have been made_. It can be proven that the answer is **unique**.
+
+**Example 1:**
+
+**Input:** s = "abbaca"
+
+**Output:** "ca"
+
+**Explanation:**
+
+For example, in "abbaca" we could remove "bb" since the letters are adjacent and equal, and this is the only possible move.
+
+The result of this move is that the string is "aaca", of which only "aa" is possible, so the final string is "ca".
+
+**Example 2:**
+
+**Input:** s = "azxxzy"
+
+**Output:** "ay"
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of lowercase English letters.

src/main/java/g1001_1100/s1048_longest_string_chain/Solution.java

@@ -0,0 +1,59 @@
+package g1001_1100.s1048_longest_string_chain;
+
+// #Medium #Array #String #Hash_Table #Dynamic_Programming #Two_Pointers
+// #2022_02_28_Time_23_ms_(97.92%)_Space_46.6_MB_(66.36%)
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@SuppressWarnings("unchecked")
+public class Solution {
+    public int longestStrChain(String[] words) {
+        List[] lenStr = new List[20];
+        for (String word : words) {
+            int len = word.length();
+            if (lenStr[len] == null) {
+                lenStr[len] = new ArrayList<String>();
+            }
+            lenStr[len].add(word);
+        }
+        Map<String, Integer> longest = new HashMap<>();
+        int max = 0;
+        for (String s : words) {
+            max = Math.max(findLongest(s, lenStr, longest), max);
+        }
+        return max;
+    }
+
+    public int findLongest(String word, List<String>[] lenStr, Map<String, Integer> longest) {
+        if (longest.containsKey(word)) {
+            return longest.get(word);
+        }
+        int len = word.length();
+        List<String> words = lenStr[len + 1];
+        if (words == null) {
+            longest.put(word, 1);
+            return 1;
+        }
+        int max = 0;
+        int i;
+        int j;
+        for (String w : words) {
+            i = 0;
+            j = 0;
+            while (i < len && j - i <= 1) {
+                if (word.charAt(i) == w.charAt(j++)) {
+                    ++i;
+                }
+            }
+            if (j - i <= 1) {
+                max = Math.max(findLongest(w, lenStr, longest), max);
+            }
+        }
+        ++max;
+        longest.put(word, max);
+        return max;
+    }
+}

src/main/java/g1001_1100/s1048_longest_string_chain/readme.md

@@ -0,0 +1,43 @@
+1048\. Longest String Chain
+
+Medium
+
+You are given an array of `words` where each word consists of lowercase English letters.
+
+<code>word<sub>A</sub></code> is a **predecessor** of <code>word<sub>B</sub></code> if and only if we can insert **exactly one** letter anywhere in <code>word<sub>A</sub></code> **without changing the order of the other characters** to make it equal to <code>word<sub>B</sub></code>.
+
+*   For example, `"abc"` is a **predecessor** of `"abac"`, while `"cba"` is not a **predecessor** of `"bcad"`.
+
+A **word chain** is a sequence of words <code>[word<sub>1</sub>, word<sub>2</sub>, ..., word<sub>k</sub>]</code> with `k >= 1`, where <code>word<sub>1</sub></code> is a **predecessor** of <code>word<sub>2</sub></code>, <code>word<sub>2</sub></code> is a **predecessor** of <code>word<sub>3</sub></code>, and so on. A single word is trivially a **word chain** with `k == 1`.
+
+Return _the **length** of the **longest possible word chain** with words chosen from the given list of_ `words`.
+
+**Example 1:**
+
+**Input:** words = ["a","b","ba","bca","bda","bdca"]
+
+**Output:** 4
+
+**Explanation:**: One of the longest word chains is ["a","ba","bda","bdca"].
+
+**Example 2:**
+
+**Input:** words = ["xbc","pcxbcf","xb","cxbc","pcxbc"]
+
+**Output:** 5
+
+**Explanation:** All the words can be put in a word chain ["xb", "xbc", "cxbc", "pcxbc", "pcxbcf"].
+
+**Example 3:**
+
+**Input:** words = ["abcd","dbqca"]
+
+**Output:** 1
+
+**Explanation:** The trivial word chain ["abcd"] is one of the longest word chains. ["abcd","dbqca"] is not a valid word chain because the ordering of the letters is changed.
+
+**Constraints:**
+
+*   `1 <= words.length <= 1000`
+*   `1 <= words[i].length <= 16`
+*   `words[i]` only consists of lowercase English letters.

src/test/java/g1001_1100/s1047_remove_all_adjacent_duplicates_in_string/SolutionTest.java

@@ -0,0 +1,18 @@
+package g1001_1100.s1047_remove_all_adjacent_duplicates_in_string;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void removeDuplicates() {
+        assertThat(new Solution().removeDuplicates("abbaca"), equalTo("ca"));
+    }
+
+    @Test
+    void removeDuplicates2() {
+        assertThat(new Solution().removeDuplicates("azxxzy"), equalTo("ay"));
+    }
+}

src/test/java/g1001_1100/s1048_longest_string_chain/SolutionTest.java

@@ -0,0 +1,28 @@
+package g1001_1100.s1048_longest_string_chain;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void longestStrChain() {
+        assertThat(
+                new Solution().longestStrChain(new String[] {"a", "b", "ba", "bca", "bda", "bdca"}),
+                equalTo(4));
+    }
+
+    @Test
+    void longestStrChain2() {
+        assertThat(
+                new Solution()
+                        .longestStrChain(new String[] {"xbc", "pcxbcf", "xb", "cxbc", "pcxbc"}),
+                equalTo(5));
+    }
+
+    @Test
+    void longestStrChain3() {
+        assertThat(new Solution().longestStrChain(new String[] {"abcd", "dbqca"}), equalTo(1));
+    }
+}