Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/1071.html

1071. Greatest Common Divisor of Strings (Easy)

For two strings s and t, we say "t divides s" if and only if s = t + ... + t  (t concatenated with itself 1 or more times)

Given two strings str1 and str2, return the largest string x such that x divides both str1 and 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: ""

Example 4:

Input: str1 = "ABCDEF", str2 = "ABC"
Output: ""

 

Constraints:

• 1 <= str1.length <= 1000
• 1 <= str2.length <= 1000
• str1 and str2 consist of English uppercase letters.

Related Topics:
String

Solution 1. Brute Force

// OJ: https://leetcode.com/problems/greatest-common-divisor-of-strings/
// Time: O(S^2)
// Space: O(S)
class Solution {
private:
    bool divisible(string a, string b) {
        int i = 0, j = 0, M = a.size(), N = b.size();
        for (; i < M; ++i) {
            if (a[i] != b[j]) return false;
            if (++j == N) j = 0;
        }
        return true;
    }
public:
    string gcdOfStrings(string str1, string str2) {
        string d = str1.size() < str2.size() ? str1 : str2;
        for (; d.size(); d.pop_back()) {
            if (str1.size() % d.size() || str2.size() % d.size()) continue;
            if (divisible(str1, d) && divisible(str2, d)) return d;
        }
        return d;
    }
};

Solution 2. GCD

// OJ: https://leetcode.com/problems/greatest-common-divisor-of-strings/
// Time: O(SH) where S is string length and H is depth of recursion
// Space: O(SH)
class Solution {
public:
    string gcdOfStrings(string str1, string str2) {
        if (str1.size() < str2.size()) return gcdOfStrings(str2, str1);
        if (str2.empty()) return str1;
        auto d = str1.substr(0, str2.size());
        return d == str2 ? gcdOfStrings(str1.substr(str2.size()), str2) : "";
    }
};

• Java
• C++
• Python
• Go

• class Solution {
      public String gcdOfStrings(String str1, String str2) {
          if (str1 == null || str2 == null)
              return null;
          while (str1.length() > 0 && str2.length() > 0) {
              if (str1.length() > str2.length()) {
                  String temp = str1;
                  str1 = str2;
                  str2 = temp;
              }
              if (str2.indexOf(str1) < 0)
                  return "";
              str2 = str2.substring(str1.length());
          }
          return str1.length() == 0 ? str2 : str1;
      }
  }
  
  ############
  
  class Solution {
      public String gcdOfStrings(String str1, String str2) {
          if (!(str1 + str2).equals(str2 + str1)) {
              return "";
          }
          int len = gcd(str1.length(), str2.length());
          return str1.substring(0, len);
      }
  
      private int gcd(int a, int b) {
          return b == 0 ? a : gcd(b, a % b);
      }
  }
  
  

• // OJ: https://leetcode.com/problems/greatest-common-divisor-of-strings/
  // Time: O(S^2)
  // Space: O(S)
  class Solution {
  private:
      bool divisible(string a, string b) {
          int i = 0, j = 0, M = a.size(), N = b.size();
          for (; i < M; ++i) {
              if (a[i] != b[j]) return false;
              if (++j == N) j = 0;
          }
          return true;
      }
  public:
      string gcdOfStrings(string str1, string str2) {
          string d = str1.size() < str2.size() ? str1 : str2;
          for (; d.size(); d.pop_back()) {
              if (str1.size() % d.size() || str2.size() % d.size()) continue;
              if (divisible(str1, d) && divisible(str2, d)) return d;
          }
          return d;
      }
  };
  

• class Solution:
      def gcdOfStrings(self, str1: str, str2: str) -> str:
          if str1 + str2 != str2 + str1:
              return ''
          n = gcd(len(str1), len(str2))
          return str1[:n]
  
  ############
  
  class Solution(object):
      def gcdOfStrings(self, str1, str2):
          """
          :type str1: str
          :type str2: str
          :rtype: str
          """
          l1, l2 = len(str1), len(str2)
          shorter = min(l1, l2)
          res = ""
          for i in range(shorter, 0, -1):
              if l1 % i or l2 % i:
                  continue
              t1, t2 = l1 // i, l2 // i
              gcd = str1[:i]
              rebuild1 = gcd * t1
              rebuild2 = gcd * t2
              if rebuild1 == str1 and rebuild2 == str2:
                  res = gcd
                  break
          return res
  

• func gcdOfStrings(str1 string, str2 string) string {
  	if str1+str2 != str2+str1 {
  		return ""
  	}
  	n := gcd(len(str1), len(str2))
  	return str1[:n]
  }
  
  func gcd(a, b int) int {
  	if b == 0 {
  		return a
  	}
  	return gcd(b, a%b)
  }
  

All Problems

All Solutions