Repeated String Match - Practice Coding Problems

Repeated String Match - Problem

Imagine you have a repeating pattern and need to find if another string can be found within that pattern when repeated enough times. Given two strings a and b, your task is to find the minimum number of times you need to repeat string a so that string b becomes a substring of the repeated pattern.

For example, if a = "abc" and b = "cabca", repeating a twice gives us "abcabc", and we can find b as a substring: "abcabcabc" (starting from position 2). So the answer would be 3 repetitions.

If it's impossible for b to be a substring of any number of repetitions of a, return -1.

Note: String "abc" repeated 0 times is "", repeated 1 time is "abc", and repeated 2 times is "abcabc".

Input & Output

example_1.py — Basic Case

$ Input: a = "abcd", b = "cdabcdab"

› Output: 3

💡 Note: We need to repeat "abcd" three times to get "abcdabcdabcd". The string "cdabcdab" appears as a substring starting at index 2.

example_2.py — Single Character

$ Input: a = "a", b = "aa"

› Output: 2

💡 Note: We need to repeat "a" twice to get "aa", which exactly matches string b.

example_3.py — Impossible Case

$ Input: a = "abc", b = "wxyz"

› Output: -1

💡 Note: String b contains characters 'w', 'x', 'y', 'z' that don't exist in string a, so it's impossible for b to be a substring of any repetition of a.

Visualization

Tap to expand

Understanding the Visualization

Pattern Analysis

Analyze what notes (characters) are available in our repeating pattern

Melody Validation

Check if our target melody uses only available notes

Calculate Repetitions

Mathematically determine minimum pattern repetitions needed

Pattern Matching

Test the calculated repetitions to find our melody

Key Takeaway

🎯 Key Insight: Like finding a melody in music, we can mathematically calculate the minimum repetitions needed and validate efficiently using character set theory.

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

We only check at most 3 possible repetition counts, each taking O(n + m) time for substring search

✓ Linear Growth

Space Complexity

O(n + m)

We store at most (len(b)//len(a) + 2) repetitions of string a

⚡ Linearithmic Space

Constraints

1 ≤ a.length, b.length ≤ 10⁴
a and b consist of lowercase English letters
Key insight: You never need more than ⌈len(b)/len(a)⌉ + 1 repetitions

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses mathematical bounds to limit the search space. We only need to check at most ⌈len(b)/len(a)⌉ + 1 repetitions, combined with an early character set validation to quickly eliminate impossible cases. This reduces both time and space complexity significantly compared to the brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Mathematical Approach	O(n + m)	O(n + m)	Calculate minimum repetitions mathematically and verify efficiently
Brute Force Approach	O(n * m * k)	O(n * k)	Keep repeating string a and check if b is a substring

Optimized Mathematical Approach — Algorithm Steps

First check if all characters in b exist in a (if not, return -1)
Calculate minimum repetitions: ceil(len(b) / len(a))
Calculate maximum repetitions: min_reps + 2 (to handle edge cases)
For each candidate repetition count, build string and check if b is substring
Return the minimum count that works, or -1 if none work

Visualization

Tap to expand

Step-by-Step Walkthrough

Character Check

Verify all chars in b exist in a: {'c','a','b'} ⊆ {'a','b','c'} ✓

Calculate Bounds

min_reps = ⌈len('cabca')/len('abc')⌉ = ⌈5/3⌉ = 2

Test min_reps=2

repeated = 'abcabc', check 'cabca' ∈ 'abcabc' → NO

Test min_reps+1=3

repeated = 'abcabcabc', check 'cabca' ∈ 'abcabcabc' → YES!

Code -

solution.c — C

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

int repeatedStringMatch(char* a, char* b) {
    if (strlen(b) == 0) return 0;
    if (strlen(a) == 0) return -1;
    
    // Quick character check
    int charA[256] = {0};
    int charB[256] = {0};
    
    for (int i = 0; a[i]; i++) charA[(unsigned char)a[i]] = 1;
    for (int i = 0; b[i]; i++) charB[(unsigned char)b[i]] = 1;
    
    for (int i = 0; i < 256; i++) {
        if (charB[i] && !charA[i]) return -1;
    }
    
    int lenA = strlen(a);
    int lenB = strlen(b);
    int minReps = (lenB + lenA - 1) / lenA;
    
    // Check min_reps and min_reps + 1
    for (int reps = minReps; reps <= minReps + 1; reps++) {
        char* repeated = malloc(lenA * reps + 1);
        repeated[0] = '\0';
        
        for (int i = 0; i < reps; i++) {
            strcat(repeated, a);
        }
        
        if (strstr(repeated, b) != NULL) {
            free(repeated);
            return reps;
        }
        
        free(repeated);
    }
    
    return -1;
}

int main() {
    char a[1000], b[1000];
    scanf("%s %s", a, b);
    printf("%d\n", repeatedStringMatch(a, b));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

We only check at most 3 possible repetition counts, each taking O(n + m) time for substring search

✓ Linear Growth

Space Complexity

O(n + m)

We store at most (len(b)//len(a) + 2) repetitions of string a

⚡ Linearithmic Space

Constraints

1 ≤ a.length, b.length ≤ 10⁴
a and b consist of lowercase English letters
Key insight: You never need more than ⌈len(b)/len(a)⌉ + 1 repetitions

67.2K Views

Medium Frequency

~18 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

Optimized Mathematical Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler