Repeated Substring Pattern - Practice Coding Problems

Repeated Substring Pattern - Problem

Pattern Recognition Challenge: Given a string s, determine if it can be constructed by taking a substring of it and repeating that substring multiple times to form the entire string.

Think of it like a wallpaper pattern - can you find a basic repeating unit that, when tiled together, creates the entire design? For example, "abcabcabc" can be constructed by repeating "abc" three times, while "abcabcab" cannot be formed by any repeating pattern.

Goal: Return true if the string follows a repeated pattern, false otherwise.

Key Insight: The repeating substring's length must be a divisor of the total string length, and it must appear consistently throughout the entire string.

Input & Output

example_1.py — Basic Repeating Pattern

$ Input: s = "abab"

› Output: true

💡 Note: The string "abab" can be constructed by repeating "ab" twice: "ab" + "ab" = "abab". The pattern "ab" has length 2, which divides the total length 4 evenly.

example_2.py — Non-Repeating Pattern

$ Input: s = "aba"

› Output: false

💡 Note: The string "aba" cannot be formed by repeating any substring. While "a" appears multiple times, "aba" is not "a" repeated, and no other substring can be repeated to form "aba".

example_3.py — Longer Repeating Pattern

$ Input: s = "abcabcabcabc"

› Output: true

💡 Note: The string can be constructed by repeating "abc" four times, or "abcabc" two times. Since at least one valid repeating pattern exists, the answer is true.

Visualization

Tap to expand

Understanding the Visualization

Identify the Wall

We have a wall (string) and need to determine if it's made of repeating tiles

Try Different Tile Sizes

Test each possible tile size from 1 to half the wall length

Check Pattern Alignment

For each tile size, verify if repeating it recreates the entire wall

Use the Mirror Trick

Advanced: Place two walls side by side - if made of tiles, the original pattern appears in the middle

Key Takeaway

🎯 Key Insight: A string has a repeating pattern if and only if we can find a substring that, when repeated multiple times, recreates the entire original string. The concatenation trick provides an elegant O(n) solution!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Modern string search algorithms (like KMP) used by built-in functions run in linear time

✓ Linear Growth

Space Complexity

O(n)

Space needed to store the concatenated string of length 2n

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁴
s consists of lowercase English letters only
The repeating pattern must appear at least twice

Asked in

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

The optimal solution uses the string concatenation trick: concatenate the string with itself, remove the first and last characters, then check if the original string appears in this modified version. This O(n) approach leverages the mathematical property that repeating patterns will align when doubled, making it both elegant and efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Possible Patterns)	O(n²)	O(n)	Try every possible substring length and check if it repeats to form the entire string
String Concatenation Trick (Optimal)	O(n)	O(n)	Concatenate string with itself, remove first and last characters, check if original appears inside

Brute Force (Try All Possible Patterns) — Algorithm Steps

Iterate through all possible pattern lengths from 1 to n//2
For each length, extract the potential pattern from the start
Calculate how many times this pattern should repeat
Check if repeating the pattern exactly recreates the original string
Return true if any pattern works, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Try length 1

Extract first character and see if it repeats throughout

Try length 2

Extract first two characters and test repetition

Continue testing

Test each valid pattern length until one works or all fail

Code -

solution.c — C

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

bool repeatedSubstringPattern(char* s) {
    int n = strlen(s);
    // Try all possible pattern lengths from 1 to n//2
    for (int patternLen = 1; patternLen <= n / 2; patternLen++) {
        // Pattern must divide string length evenly
        if (n % patternLen == 0) {
            int repetitions = n / patternLen;
            bool isPattern = true;
            // Check if pattern repeats throughout string
            for (int i = patternLen; i < n; i++) {
                if (s[i] != s[i % patternLen]) {
                    isPattern = false;
                    break;
                }
            }
            if (isPattern) {
                return true;
            }
        }
    }
    return false;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"' && s[strlen(s)-1] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = 0;
    }
    printf("%s\n", repeatedSubstringPattern(s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n/2 possible pattern lengths, we might need to check the entire string of length n

⚠ Quadratic Growth

Space Complexity

O(n)

Space needed to store the repeated pattern string for comparison

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁴
s consists of lowercase English letters only
The repeating pattern must appear at least twice

58.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

Brute Force (Try All Possible Patterns) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler