Greatest Common Divisor of Strings - Practice Coding Problems

Greatest Common Divisor of Strings - Problem

Math String Easy

Imagine you have two strings that are built by repeating smaller patterns, like DNA sequences with repeating base patterns. Your mission is to find the largest common repeating pattern that can construct both strings!

Given two strings str1 and str2, we say that string x divides a string if that string can be formed by concatenating x with itself multiple times. For example, "ab" divides "abababab" because "abababab" = "ab" + "ab" + "ab" + "ab".

Goal: Find the longest string x that divides both str1 and str2. If no such string exists, return an empty string.

Example: If str1 = "ABABAB" and str2 = "ABAB", then "AB" divides both strings, making it the greatest common divisor of strings!

Input & Output

example_1.py — Python

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

› Output: "AB"

💡 Note: Both strings can be formed by repeating "AB": "ABABAB" = "AB"+"AB"+"AB" and "ABAB" = "AB"+"AB". No longer string can divide both.

example_2.py — Python

$ Input: str1 = "AAAA", str2 = "AA"

› Output: "AA"

💡 Note: "AA" divides both strings: "AAAA" = "AA"+"AA" and "AA" = "AA". While "A" also divides both, "AA" is longer.

example_3.py — Python

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

› Output: ""

💡 Note: There is no common pattern that can divide both "LEET" and "CODE", so we return an empty string.

Visualization

Tap to expand

Understanding the Visualization

Strand Analysis

We have two DNA strands with repeating patterns

Pattern Validation

Check if both strands share the same underlying structure

Length Calculation

Find the mathematical GCD of strand lengths

Pattern Extraction

Extract the common genetic sequence

Key Takeaway

🎯 Key Insight: Mathematical properties of string divisibility allow us to solve this elegantly - if strings share a common divisor, their concatenations are commutative, and the divisor length equals the GCD of their lengths!

Time & Space Complexity

Time Complexity

⏱️

O(m + n)

String concatenation and comparison takes O(m+n), GCD calculation is O(log(min(m,n))) which is dominated by string operations

✓ Linear Growth

Space Complexity

O(m + n)

Space needed for string concatenation operations

⚡ Linearithmic Space

Constraints

1 ≤ str1.length, str2.length ≤ 1000
str1 and str2 consist of English uppercase letters only
The answer is guaranteed to be unique

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 18 f Meta 15

The optimal solution uses a brilliant mathematical insight: if two strings share a common divisor, then concatenating them in different orders yields the same result. We check if str1+str2 == str2+str1, then find the GCD of their lengths to determine the divisor length. This achieves O(m+n) time complexity compared to the brute force O(min(m,n)×(m+n)) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical GCD Approach (Optimal)	O(m + n)	O(m + n)	Use string concatenation property and mathematical GCD for optimal solution
Brute Force (Try All Lengths)	O(min(m,n) × (m+n))	O(min(m,n))	Try every possible substring length from longest to shortest

Mathematical GCD Approach (Optimal) — Algorithm Steps

Check if str1 + str2 equals str2 + str1 (prerequisite for common divisor)
If not equal, return empty string (no common divisor exists)
Calculate GCD of the lengths of both strings
Return the prefix of str1 with length equal to the GCD
This prefix is guaranteed to be the greatest common divisor

Visualization

Tap to expand

Step-by-Step Walkthrough

Concatenation Check

Verify str1+str2 equals str2+str1

Length GCD

Calculate GCD of string lengths: gcd(6,4) = 2

Extract Result

Return first 2 characters: 'AB'

Code -

solution.c — C

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

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

char* gcdOfStrings(const char* str1, const char* str2) {
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    
    // Create concatenated strings for comparison
    char* concat1 = malloc((len1 + len2 + 1) * sizeof(char));
    char* concat2 = malloc((len1 + len2 + 1) * sizeof(char));
    
    strcpy(concat1, str1);
    strcat(concat1, str2);
    
    strcpy(concat2, str2);
    strcat(concat2, str1);
    
    // Key insight: if gcd exists, str1+str2 must equal str2+str1
    if (strcmp(concat1, concat2) != 0) {
        free(concat1);
        free(concat2);
        char* empty = malloc(sizeof(char));
        empty[0] = '\0';
        return empty;
    }
    
    free(concat1);
    free(concat2);
    
    // The length of GCD string is GCD of lengths
    int gcd_length = gcd(len1, len2);
    
    // Return the prefix of str1 with GCD length
    char* result = malloc((gcd_length + 1) * sizeof(char));
    strncpy(result, str1, gcd_length);
    result[gcd_length] = '\0';
    
    return result;
}

int main() {
    char str1[1001], str2[1001];
    scanf("%s %s", str1, str2);
    
    char* result = gcdOfStrings(str1, str2);
    printf("%s\n", result);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m + n)

String concatenation and comparison takes O(m+n), GCD calculation is O(log(min(m,n))) which is dominated by string operations

✓ Linear Growth

Space Complexity

O(m + n)

Space needed for string concatenation operations

⚡ Linearithmic Space

Constraints

1 ≤ str1.length, str2.length ≤ 1000
str1 and str2 consist of English uppercase letters only
The answer is guaranteed to be unique

38.2K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Mathematical GCD Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler