add 1071

Author: fishercoder1534

README.md

@@ -27,6 +27,7 @@ Your ideas/fixes/algorithms are more than welcome!
 
 |  #  |      Title     |   Solutions   | Time          | Space         | Video  | Difficulty  | Tag                   
 |-----|----------------|---------------|---------------|---------------|--------|-------------|-------------
+|1071|[Greatest Common Divisor of Strings](https://leetcode.com/problems/greatest-common-divisor-of-strings/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1071.java) | O(m*n) | O(1) | |Easy||
 |1065|[Index Pairs of a String](https://leetcode.com/problems/index-pairs-of-a-string/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1065.java) | O(nlogn) | O(1) | |Medium||
 |1056|[Confusing Number](https://leetcode.com/problems/confusing-number/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1056.java) | O(n) | O(1) | |Easy||
 |1055|[Fixed Point](https://leetcode.com/problems/fixed-point/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1055.java) | O(n) | O(1) | |Easy||

src/main/java/com/fishercoder/solutions/_1071.java

@@ -0,0 +1,90 @@
+package com.fishercoder.solutions;
+
+/**
+ * 1071. Greatest Common Divisor of Strings
+ *
+ * For strings S and T, we say "T divides S" if and only if S = T + ... + T  (T concatenated with itself 1 or more times)
+ * Return the largest string X such that X divides str1 and X divides str2.
+ *
+ * Example 1:
+ * Input: str1 = "ABCABC", str2 = "ABC"
+ * Output: "ABC"
+ *
+ * Example 2:
+ * Input: str1 = "ABABAB", str2 = "ABAB"
+ * Output: "AB"
+ *
+ * Example 3:
+ * Input: str1 = "LEET", str2 = "CODE"
+ * Output: ""
+ *
+ * Note:
+ *
+ * 1 <= str1.length <= 1000
+ * 1 <= str2.length <= 1000
+ * str1[i] and str2[i] are English uppercase letters.
+ * */
+public class _1071 {
+    public static class Solution1 {
+        public String gcdOfStrings(String str1, String str2) {
+            if (str1.isEmpty() || str2.isEmpty()) {
+                return "";
+            }
+            String commomDivisor = str2;
+            while (commomDivisor != null && !commomDivisor.isEmpty()) {
+                if (isDivisor(str1, commomDivisor)) {
+                    return commomDivisor;
+                } else {
+                    commomDivisor = findNextShorterCommonDivisor(str2, commomDivisor);
+                }
+            }
+            return "";
+        }
+
+        private String findNextShorterCommonDivisor(String str2, String commomDivisor) {
+            int length = nextPossibleLength(str2, commomDivisor.length() - 1);
+            while (length > 1) {
+                if (isDivisor(str2, length)) {
+                    return str2.substring(0, length);
+                }
+                length = nextPossibleLength(str2, length - 1);
+            }
+            return null;
+        }
+
+        private boolean isDivisor(String str2, int length) {
+            String commonDivisorCandidate = str2.substring(0, length);
+            for (int i = 0; i < str2.length() - length; i += length) {
+                if (!str2.substring(i, i + length).equals(commonDivisorCandidate)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        private int nextPossibleLength(String str2, int bound) {
+            if (bound <= 0) {
+                return -1;
+            }
+            int len = bound;
+            while (str2.length() % len != 0) {
+                len--;
+            }
+            return len;
+        }
+
+        private boolean isDivisor(String str1, String commomDivisor) {
+            if (str1.length() == commomDivisor.length()) {
+                return str1.equals(commomDivisor);
+            }
+            int i = 0;
+            for (; i < str1.length() - commomDivisor.length(); i += commomDivisor.length()) {
+                if (!str1.substring(i, i + commomDivisor.length()).equals(commomDivisor)) {
+                    return false;
+                }
+            }
+            return i == (str1.length() - commomDivisor.length());
+        }
+
+    }
+}

src/test/java/com/fishercoder/_1071Test.java

@@ -0,0 +1,37 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._1071;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _1071Test {
+    private static _1071.Solution1 solution1;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _1071.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        assertEquals("ABC", solution1.gcdOfStrings("ABCABC", "ABC"));
+    }
+
+    @Test
+    public void test2() {
+        assertEquals("AB", solution1.gcdOfStrings("ABABAB", "ABAB"));
+    }
+
+    @Test
+    public void test3() {
+        assertEquals("", solution1.gcdOfStrings("LEET", "CODE"));
+    }
+
+    @Test
+    public void test4() {
+        assertEquals("", solution1.gcdOfStrings("ABCABCD", "ABC"));
+    }
+
+}