Update GCD problem

Author: sudheerj

README.md

@@ -98,7 +98,7 @@ List of Programs related to data structures and algorithms
 
    9. Encode and decode strings: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/9.encodeDecodeStrings/encodeDecodeStrings.js)  [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/9.encodeDecodeStrings/encodeDecodeStrings.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/9.encodeDecodeStrings/encodeDecodeStrings.md)
 
-   10. Greatest common devisor of strings: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/greatestCommonDivisor.js)
+   10. Greatest common devisor of strings: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/10.greatestCommonDivisor/greatestCommonDivisor.js)  [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/10.greatestCommonDivisor/greatestCommonDivisor.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/10.greatestCommonDivisor/greatestCommonDivisor.md)
 
 ### Dynamic programming
 

src/java1/algorithms/strings/MinWindowSubstring.java

@@ -0,0 +1,54 @@
+package java1.algorithms.strings.greatestCommonDivisor;
+
+public class GreatestCommonDivisor {
+    //1. GCD using Euclidean's algorithm TC: O(n+m)(i.e, O(n + m + log(min(n, m)))), SC: O(n+m)
+    private static String gcdOfStrings1(String str1, String str2) {
+        if(!((str1+str2).equals(str2+str1))) return "";
+
+        int gcdLength = gcd(str1.length(), str2.length());
+
+        return str1.substring(0, gcdLength);
+
+    }
+
+    private static int gcd(int a, int b){
+        return b == 0 ? a : gcd(b, a%b);
+    }
+
+    // 2. BrutForce (Time complexity: O(min(m,n) . (m+n)), Space complexity: O(min(m,n)))
+    private static String gcdOfStrings2(String str1, String str2) {
+        int l1 = str1.length(), l2 = str2.length();
+
+        for(int i = Math.min(l1, l2); i >=1; i++){
+            if(hasGcdString(str1, str2, i)) {
+                return str1.substring(0, i);
+            }
+        }
+
+        return "";
+    }
+
+    private static boolean hasGcdString(String str1, String str2, int k){
+        int l1 = str1.length(), l2 = str2.length();
+
+        if(l1%k > 0 || l2%k > 0){
+            return false;
+        }
+
+        int f1 = l1/k, f2 = l2/k;
+        String base = str1.substring(0, k);
+
+        return base.repeat(f1) == str1 && base.repeat(f2) == str2;
+    }
+    
+    public static void main(String[] args) {
+        System.out.println(gcdOfStrings1("AB", "AB"));
+        System.out.println(gcdOfStrings1("ABCABCABC", "ABCABC"));
+        System.out.println(gcdOfStrings1("ABABAB", "AB"));
+
+        System.out.println(gcdOfStrings2("AB", "AB"));
+        System.out.println(gcdOfStrings2("ABCABCABC", "ABCABC"));
+        System.out.println(gcdOfStrings2("ABABAB", "AB"));
+    }
+}
+

src/java1/algorithms/strings/greatestCommonDivisor/GreatestCommonDivisor.java

@@ -0,0 +1,35 @@
+**Description:**
+Given two strings `str1` and `str2`, return the largest string `x` such that it divides both `str1` and `str2`.
+
+**Note:** For any two strings `a` and `b`, we say "b divides a" if and only if `a = b + b +... + a`.
+
+### Examples
+Example 1:
+Input: ["AB", "AB"]
+Output: ["AB"]
+
+Example 2:
+Input: ["ABCABCABC", "ABCABC"]
+Output: ["ABCABC"]
+
+Example 3:
+Input: ["ABABAB", "AB"]
+Output: ["AB"]
+
+
+**Algorithmic Steps**
+This problem is solved with the help of basic string operations and **Euclidean's** algorithm. The algorithmic approach can be summarized as follows:
+
+1. Add a preliminary check if the two strings can be constructed from a common substring. It can be verified by comparing `str1+str2` with `str2+str1`. If they are not equal, there is no chanced of GCD.
+
+2. Implement a gcd of two string lengths using Euclidean's algorithm.
+
+3. Invoke the method created in step2 and assign to a variable `gcdLength`.
+
+4. Return a substring on either of strings( `str1` or `str2`) using 0 as first argument and `gcdLength` as second argument.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n+m)` where `n` is the length of first string and `m` is the length of second string. This is because both the string concatenation and comparison takes will time complexity of `O(n+m)` individually. Also, Euclid's algorithm takes time complexity of `O(log(min(n, m)))`. So, the overall time complexity combining these operations resulting in `O(n + m + log(min(n, m))) ~= O(n+m)`.
+
+Also, it takes space complexity of `O(n+m)` due to additional space required for concatenated strings.

src/java1/algorithms/strings/greatestCommonDivisor/GreatestCommonDivisor.md

@@ -0,0 +1,53 @@
+//1. GCD using Euclidean's algorithm TC: O(n+m)(i.e, O(n + m + log(min(n, m)))), SC: O(n+m)
+function gcdOfStrings1(string1, string2){
+    //Verify whether GCD strings exists or not
+    if(!(string1+string2 === string2+string1)) {
+        return false;
+    }
+
+    let gcdLength = gcd(string1.length, string2.length);
+    return string1.substring(0, gcdLength);
+}
+
+function gcd(x, y) {
+    if(y === 0) {
+        return x;
+    }
+    return gcd(y, x%y);
+}
+
+// 2. BrutForce (Time complexity: O(min(m,n) . (m+n)), Space complexity: O(min(m,n)))
+function gcdOfStrings2(string1, string2) {
+    let l1 = string1.length;
+    let l2 = string2.length;
+
+    for(let i= Math.min(l1,l2); i >= 1; i--) {
+        if(hasGcdString(string1, string2, i)) {
+            return string1.substring(0, i);
+        }
+    }
+
+    return "";
+}
+
+function hasGcdString(string1, string2, k) {
+    let l1 = string1.length;
+    let l2 = string2.length;
+
+    if(l1%k > 0 || l2%k >0) {
+        return false;
+    }
+
+    let f1= l1/k, f2 = l2/k;
+    let base = string1.substring(0, k);
+    return base.repeat(f1) === string1 && base.repeat(f2) === string2;
+}
+
+
+console.log(gcdOfStrings1("AB", "AB"));
+console.log(gcdOfStrings1("ABCABCABC", "ABCABC"));
+console.log(gcdOfStrings1("ABABAB", "AB"));
+
+console.log(gcdOfStrings2("AB", "AB"));
+console.log(gcdOfStrings2("ABCABCABC", "ABCABC"));
+console.log(gcdOfStrings2("ABABAB", "AB"));

src/javascript/algorithms/strings/10.greatestCommonDivisor/greatestCommonDivisor.js

@@ -0,0 +1,35 @@
+**Description:**
+Given two strings `str1` and `str2`, return the largest string `x` such that it divides both `str1` and `str2`.
+
+**Note:** For any two strings `a` and `b`, we say "b divides a" if and only if `a = b + b +... + a`.
+
+### Examples
+Example 1:
+Input: ["AB", "AB"]
+Output: ["AB"]
+
+Example 2:
+Input: ["ABCABCABC", "ABCABC"]
+Output: ["ABCABC"]
+
+Example 3:
+Input: ["ABABAB", "AB"]
+Output: ["AB"]
+
+
+**Algorithmic Steps**
+This problem is solved with the help of basic string operations and **Euclidean's** algorithm. The algorithmic approach can be summarized as follows:
+
+1. Add a preliminary check if the two strings can be constructed from a common substring. It can be verified by comparing `str1+str2` with `str2+str1`. If they are not equal, there is no chanced of GCD.
+
+2. Implement a gcd of two string lengths using Euclidean's algorithm.
+
+3. Invoke the method created in step2 and assign to a variable `gcdLength`.
+
+4. Return a substring on either of strings( `str1` or `str2`) using 0 as first argument and `gcdLength` as second argument.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n+m)` where `n` is the length of first string and `m` is the length of second string. This is because both the string concatenation and comparison takes will time complexity of `O(n+m)` individually. Also, Euclid's algorithm takes time complexity of `O(log(min(n, m)))`. So, the overall time complexity combining these operations resulting in `O(n + m + log(min(n, m))) ~= O(n+m)`.
+
+Also, it takes space complexity of `O(n+m)` due to additional space required for concatenated strings.