Distinct Echo Substrings - Practice Coding Problems

Distinct Echo Substrings - Problem

Given a string text, find the number of distinct echo substrings.

An echo substring is a non-empty substring that can be written as the concatenation of some string with itself. In other words, it can be written as a + a where a is some string.

Example: In the string "abcabc", the substring "abcabc" is an echo substring because it equals "abc" + "abc". Similarly, "aa" is an echo substring in "baab" because it equals "a" + "a".

Your task is to count how many distinct echo substrings exist in the given text. Two echo substrings are considered the same if they have identical characters in the same order.

Input & Output

example_1.py — Basic Echo Pattern

$ Input: text = "abcabc"

› Output: 2

💡 Note: The echo substrings are "abcabc" (abc+abc) and any repeated single characters if they exist. In this case, we have "abcabc" as one echo substring.

example_2.py — Multiple Patterns

$ Input: text = "aabaaba"

› Output: 4

💡 Note: The echo substrings are: "aa" (a+a), "aaba" (aa+ba), "baab" (ba+ab), and "aabaaba" (aaba+aaba). Each represents a unique echo pattern.

example_3.py — No Echo Patterns

$ Input: text = "abcd"

› Output: 0

💡 Note: No substring can be split into two identical halves, so there are no echo substrings.

Visualization

Tap to expand

Understanding the Visualization

Scan Position

Choose a starting position in the string

Expand Outward

Gradually expand to form potential echo substrings

Hash Comparison

Use rolling hash to quickly compare halves

Verify Match

Confirm the echo pattern with actual string comparison

Store Result

Add distinct echo substrings to result set

Key Takeaway

🎯 Key Insight: Rolling hash allows us to compare substring halves in O(1) time, making echo detection much more efficient than naive string comparison.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) positions × O(n) expansions, but with O(1) hash comparisons

⚠ Quadratic Growth

Space Complexity

O(n²)

Storing distinct echo substrings in the set

⚠ Quadratic Space

Constraints

1 ≤ text.length ≤ 2000
text consists of lowercase English letters only
Echo substring must have even length (since it's a+a)
All substrings must be non-empty

Asked in

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

The optimal solution uses Rolling Hash technique to efficiently detect echo substrings in O(n²) time. For each starting position, we expand outwards while maintaining hash values for both halves of potential echo substrings. When hash values match, we verify the actual strings to handle hash collisions. This approach is much faster than the brute force O(n³) solution while maintaining correctness.

Common Approaches

Approach	Time	Space	Notes
✓ Rolling Hash (Optimal)	O(n²)	O(n²)	Use rolling hash to efficiently detect echo patterns in one pass
Brute Force (Check All Substrings)	O(n³)	O(n³)	Check every possible substring to see if it's an echo

Rolling Hash (Optimal) — Algorithm Steps

For each possible center position in the string
Expand outwards maintaining rolling hashes for left and right halves
When left hash equals right hash, verify it's a true echo
Add verified echo substrings to a set for distinctness
Continue until all positions are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Hashes

Start with empty left and right rolling hashes

Expand and Hash

Add characters to both hashes as we expand

Compare Hashes

When hashes match, verify actual strings

Store Result

Add confirmed echo to result set

Code -

solution.c — C

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

#define MAX_LEN 2000
#define MAX_SUBSTRINGS 100000
#define MOD 1000000007
#define BASE 31

char substrings[MAX_SUBSTRINGS][MAX_LEN];
int substring_count = 0;

int findSubstring(char* str) {
    for (int i = 0; i < substring_count; i++) {
        if (strcmp(substrings[i], str) == 0) {
            return 1;
        }
    }
    return 0;
}

int distinctEchoSubstrings(char* text) {
    int n = strlen(text);
    substring_count = 0;
    
    // For each starting position
    for (int i = 0; i < n; i++) {
        long long leftHash = 0;
        long long rightHash = 0;
        long long power = 1;
        
        // Expand from position i
        for (int length = 1; length <= (n - i) / 2; length++) {
            if (i + 2 * length > n) break;
            
            // Add character to left hash
            leftHash = (leftHash * BASE + (text[i + length - 1] - 'a' + 1)) % MOD;
            
            // Add character to right hash
            rightHash = ((text[i + length] - 'a' + 1) * power + rightHash) % MOD;
            power = (power * BASE) % MOD;
            
            // If hashes match, verify the actual strings
            if (leftHash == rightHash) {
                char substring[MAX_LEN];
                strncpy(substring, text + i, 2 * length);
                substring[2 * length] = '\0';
                
                // Verify it's actually an echo
                int isEcho = 1;
                for (int k = 0; k < length; k++) {
                    if (substring[k] != substring[k + length]) {
                        isEcho = 0;
                        break;
                    }
                }
                
                if (isEcho && !findSubstring(substring)) {
                    strcpy(substrings[substring_count], substring);
                    substring_count++;
                }
            }
        }
    }
    
    return substring_count;
}

int main() {
    char text[MAX_LEN];
    scanf("%s", text);
    
    // Remove quotes if present
    int len = strlen(text);
    if (text[0] == '"' && text[len-1] == '"') {
        text[len-1] = '\0';
        memmove(text, text + 1, len - 1);
    }
    
    printf("%d\n", distinctEchoSubstrings(text));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) positions × O(n) expansions, but with O(1) hash comparisons

⚠ Quadratic Growth

Space Complexity

O(n²)

Storing distinct echo substrings in the set

⚠ Quadratic Space

Constraints

1 ≤ text.length ≤ 2000
text consists of lowercase English letters only
Echo substring must have even length (since it's a+a)
All substrings must be non-empty

31.6K Views

Medium Frequency

~25 min Avg. Time

847 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

Rolling Hash (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler