Number of Same-End Substrings - Practice Coding Problems

Number of Same-End Substrings - Problem

Array Hash Table String Counting Prefix Sum Medium

String Pattern Matching Challenge

You're given a string s and multiple query ranges. For each query range [li, ri], you need to find how many same-end substrings exist within that substring.

A same-end substring is any substring where the first and last characters are identical. For example, in the string "aba", the same-end substrings are: "a" (position 0), "b" (position 1), "a" (position 2), and "aba" (the entire string).

Goal: For each query range, efficiently count all possible same-end substrings within that range.

Input: A string s and a 2D array queries where each query is [left_index, right_index]
Output: An array where each element is the count of same-end substrings for the corresponding query

Input & Output

example_1.py — Basic Case

$ Input: s = "abcaa", queries = [[0,2],[1,3],[0,4]]

› Output: [3, 2, 6]

💡 Note: For query [0,2] on substring "abc": same-end substrings are "a", "b", "c" (3 total). For query [1,3] on "bca": same-end substrings are "b", "c", "a" (2 total). For query [0,4] on "abcaa": same-end substrings are "a"(×5), "b", "c", "aa", "aba", "aca", "abcaa" but only "a"(positions 0,3,4), "b"(position 1), "c"(position 2), "aa"(positions 3-4), "aba"(positions 0-3), "aca"(positions 0-4) giving us 6 total.

example_2.py — Repeated Characters

$ Input: s = "aaaa", queries = [[0,3],[1,2]]

› Output: [10, 3]

💡 Note: For "aaaa" with 4 'a's, same-end substrings are: 4 single 'a's + 3 "aa"s + 2 "aaa"s + 1 "aaaa" = 10 total. For substring "aa" (positions 1-2): 2 single 'a's + 1 "aa" = 3 total. This follows the formula n*(n+1)/2 where n is the frequency of each character.

example_3.py — Single Character

$ Input: s = "x", queries = [[0,0]]

› Output: [1]

💡 Note: Edge case with single character. The only substring is "x" itself, which is same-end (first and last character are both 'x'). So the answer is 1.

Constraints

1 ≤ s.length ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
queries[i] = [l_i, r_i] where 0 ≤ l_i ≤ r_i < s.length
s consists of only lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Count Character Frequencies

For each query range, count how many times each character appears

Apply Combinatorial Formula

For n occurrences of a character, there are n*(n+1)/2 same-end substrings

Sum All Contributions

Add up the contributions from all character types in the range

Key Takeaway

🎯 Key Insight: Same-end substrings depend only on character frequencies, not positions. Use prefix sums for fast range frequency queries, then apply the triangular number formula f*(f+1)/2 for each character.

Asked in

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

The optimal solution uses prefix sum arrays to preprocess character frequencies, allowing O(1) range queries. For each character with frequency f in a query range, we add f*(f+1)/2 same-end substrings using the combinatorial formula. The key insight is that same-end substrings are determined by character frequencies, not positions.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Prefix Sum (Optimal)	O(N + K*Q)	O(K*N)	Use a single hash map to track only characters present in the string for efficient computation
Character Frequency with Prefix Sums	O(26N + 26Q)	O(26*N)	Build character frequency arrays, then use prefix sums to quickly answer queries
Brute Force (Check All Substrings)	O(Q * N³)	O(1)	For each query, examine every possible substring and check if first and last characters match

Optimized Prefix Sum (Optimal) — Algorithm Steps

Identify unique characters in the string and create prefix arrays only for them
Build prefix sum arrays for each unique character
For each query, iterate only through characters present in the string
Apply the combinatorial formula f*(f+1)/2 for each character's frequency

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Unique Characters

Find all unique characters in the string

Build Compact Prefix Arrays

Create prefix arrays only for existing characters

Efficient Query Processing

Process queries using only relevant characters

Code -

solution.c — C

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

int* sameEndSubstringCount(char* s, int queries[][2], int querySize, int* returnSize) {
    int n = strlen(s);
    // Find unique characters
    bool seen[26] = {false};
    int uniqueCount = 0;
    char uniqueChars[26];
    
    for (int i = 0; i < n; i++) {
        int idx = s[i] - 'a';
        if (!seen[idx]) {
            seen[idx] = true;
            uniqueChars[uniqueCount++] = s[i];
        }
    }
    
    // Build prefix sum arrays only for unique characters
    int prefix[uniqueCount][n + 1];
    memset(prefix, 0, sizeof(prefix));
    
    for (int i = 0; i < n; i++) {
        int charIdx = -1;
        for (int k = 0; k < uniqueCount; k++) {
            if (uniqueChars[k] == s[i]) {
                charIdx = k;
                break;
            }
        }
        
        for (int j = 0; j < uniqueCount; j++) {
            prefix[j][i + 1] = prefix[j][i] + (j == charIdx ? 1 : 0);
        }
    }
    
    int* result = (int*)malloc(querySize * sizeof(int));
    *returnSize = querySize;
    
    for (int q = 0; q < querySize; q++) {
        int left = queries[q][0], right = queries[q][1];
        int count = 0;
        
        for (int j = 0; j < uniqueCount; j++) {
            int freq = prefix[j][right + 1] - prefix[j][left];
            count += freq * (freq + 1) / 2;
        }
        result[q] = count;
    }
    
    return result;
}

int main() {
    char s[] = "abcaa";
    int queries[][2] = {{0, 2}, {1, 3}, {0, 4}};
    int returnSize;
    
    int* result = sameEndSubstringCount(s, queries, 3, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(N + K*Q)

O(N) for preprocessing, O(K*Q) for queries where K is the number of unique characters (at most 26)

✓ Linear Growth

Space Complexity

O(K*N)

Only store prefix arrays for K unique characters instead of all 26

✓ Linear Space

43.3K Views

Medium-High Frequency

~25 min Avg. Time

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

Optimized Prefix Sum (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler