Greatest Common Divisor of Strings

Greatest Common Divisor of Strings - Problem

Math String Easy

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

Given two strings str1 and str2, return the largest string x such that x divides both str1 and str2.

Input & Output

Example 1 — Basic Case

$ Input: str1 = "ABCABC", str2 = "ABC"

› Output: "ABC"

💡 Note: "ABC" divides "ABCABC" (ABC + ABC) and divides "ABC" (ABC × 1). This is the largest such string.

Example 2 — No Common Divisor

$ Input: str1 = "ABABAB", str2 = "ABAB"

› Output: "AB"

💡 Note: "AB" can build both: "ABABAB" = AB + AB + AB and "ABAB" = AB + AB

Example 3 — No Common Pattern

$ Input: str1 = "LEET", str2 = "CODE"

› Output: ""

💡 Note: No string can divide both "LEET" and "CODE" since they share no common repeating pattern

Constraints

1 ≤ str1.length, str2.length ≤ 1000
str1 and str2 consist of English uppercase letters

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8

The key insight is that if two strings have a greatest common divisor string, then concatenating them in either order produces the same result: str1 + str2 = str2 + str1. The optimal approach uses this mathematical property combined with GCD of string lengths. Time: O(m+n), Space: O(m+n).

Common Approaches

✓ Brute Force - Check All Substrings

⏱️ Time: O(min(m,n)³) Space: O(min(m,n))

Try all substrings of the shorter string, starting from the longest, and check if each can divide both strings by repeated concatenation.

Mathematical Approach with GCD

⏱️ Time: O(m + n) Space: O(m + n)

First validate that a common divisor exists using string concatenation property, then use GCD of string lengths to find the optimal length.

Brute Force - Check All Substrings — Algorithm Steps

Find the shorter string length
Try each substring from longest to shortest
For each substring, check if it can build both strings
Return the first valid divisor found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Candidates

Try substrings from longest to shortest

Test Division

Check if candidate can build both strings

Return First Match

First valid divisor is the longest

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int canDivide(const char* s, const char* divisor) {
    int sLen = strlen(s);
    int divLen = strlen(divisor);
    if (sLen % divLen != 0) {
        return 0;
    }
    int times = sLen / divLen;
    for (int i = 0; i < times; i++) {
        for (int j = 0; j < divLen; j++) {
            if (s[i * divLen + j] != divisor[j]) {
                return 0;
            }
        }
    }
    return 1;
}

char* solution(char* str1, char* str2) {
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    int minLen = (len1 < len2) ? len1 : len2;
    
    static char result[1001];
    
    // Try all possible divisor lengths from longest to shortest
    for (int length = minLen; length >= 1; length--) {
        // Try substring from str1
        char candidate[1001];
        strncpy(candidate, str1, length);
        candidate[length] = '\0';
        
        if (canDivide(str1, candidate) && canDivide(str2, candidate)) {
            strcpy(result, candidate);
            return result;
        }
        
        // Try substring from str2 if different
        strncpy(candidate, str2, length);
        candidate[length] = '\0';
        if (strcmp(candidate, str1) != 0 || length != len1) {
            if (canDivide(str1, candidate) && canDivide(str2, candidate)) {
                strcpy(result, candidate);
                return result;
            }
        }
    }
    
    result[0] = '\0';
    return result;
}

int main() {
    char str1[1001], str2[1001];
    fgets(str1, sizeof(str1), stdin);
    fgets(str2, sizeof(str2), stdin);
    
    // Remove newlines
    str1[strcspn(str1, "\n")] = 0;
    str2[strcspn(str2, "\n")] = 0;
    
    char* result = solution(str1, str2);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(min(m,n)³)

O(min(m,n)) substrings, each taking O(min(m,n)) time to check against strings of length O(m+n)

✓ Linear Growth

Space Complexity

O(min(m,n))

Space for storing substring candidates

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Substrings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler