Number of Same-End Substrings

Number of Same-End Substrings - Problem

Array Hash Table String Counting Prefix Sum Medium

You are given a 0-indexed string s, and a 2D array of integers queries, where queries[i] = [li, ri] indicates a substring of s starting from the index li and ending at the index ri (both inclusive), i.e. s[li..ri].

Return an array ans where ans[i] is the number of same-end substrings of queries[i].

A 0-indexed string t of length n is called same-end if it has the same character at both of its ends, i.e., t[0] == t[n - 1].

A substring is a contiguous non-empty sequence of characters within a string.

Input & Output

Example 1 — Basic Case

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

› Output: [7,4]

💡 Note: For query [0,4] (whole string): 'a' appears 2 times → 3 substrings, 'b' appears 2 times → 3 substrings, 'c' appears 1 time → 1 substring. Total: 7. For query [1,3] ("bcb"): 'b' appears 2 times → 3 substrings, 'c' appears 1 time → 1 substring. Total: 4.

Example 2 — Single Character

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

› Output: [10]

💡 Note: All characters are 'a', appearing 4 times. Using formula: 4×5/2 = 10 same-end substrings.

Example 3 — No Repeats

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

› Output: [4,2]

💡 Note: For [0,3]: each character appears once, so 1×2/2 × 4 = 4. For [1,2]: 'b' and 'c' each appear once, so 1×2/2 × 2 = 2.

Constraints

1 ≤ s.length ≤ 10⁴
1 ≤ queries.length ≤ 10⁴
s consists of only lowercase English letters
0 ≤ li ≤ ri < s.length

Visualization

Tap to expand

Asked in

G Google 45 M Microsoft 38 a Amazon 32 f Facebook 28

The key insight is that for any character appearing n times in a range, it contributes exactly n×(n+1)/2 same-end substrings. The optimal approach uses prefix sum arrays to precompute character counts, enabling O(1) query answering. Time: O(N + Q), Space: O(N × 26)

Common Approaches

✓ Brute Force

⏱️ Time: O(Q × N³) Space: O(1)

For each query range, generate all possible substrings and count those where the first and last characters are the same. This involves checking every possible start and end position within the query range.

Character Frequency Count

⏱️ Time: O(Q × N) Space: O(1)

For each query, count the frequency of each character in the range. For each character that appears n times, it contributes n*(n+1)/2 same-end substrings. This is because any two positions with the same character form a valid same-end substring.

Prefix Sum Optimization

⏱️ Time: O(N + Q) Space: O(N × 26)

Build a 2D prefix sum array where prefix[i][c] represents the count of character c from index 0 to i. This allows us to compute the character frequency in any range [l,r] in constant time using prefix[r][c] - prefix[l-1][c].

Brute Force — Algorithm Steps

For each query [l, r], iterate through all possible substring start positions
For each start position, check all possible end positions
Count substrings where s[start] == s[end]

Visualization

Tap to expand

Step-by-Step Walkthrough

Query Range

Extract substring from l to r

Check All Pairs

Compare every start-end position pair

Count Matches

Count pairs where characters match

Code -

solution.c — C

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

int* solution(char* s, int queries[][2], int queryCount, int* returnSize) {
    int* result = (int*)malloc(queryCount * sizeof(int));
    *returnSize = queryCount;
    
    for (int q = 0; q < queryCount; q++) {
        int l = queries[q][0], r = queries[q][1];
        int count = 0;
        
        // Check all possible substrings in range [l, r]
        for (int i = l; i <= r; i++) {
            for (int j = i; j <= r; j++) {
                // Check if substring has same start and end character
                if (s[i] == s[j]) {
                    count++;
                }
            }
        }
        result[q] = count;
    }
    
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char queriesStr[10000];
    fgets(queriesStr, sizeof(queriesStr), stdin);
    
    // Simple parsing for queries - assumes format [[a,b],[c,d],...]
    int queries[100][2];
    int queryCount = 0;
    char* ptr = queriesStr;
    while ((ptr = strchr(ptr, '[')) != NULL) {
        ptr++;
        if (sscanf(ptr, "%d,%d", &queries[queryCount][0], &queries[queryCount][1]) == 2) {
            queryCount++;
        }
    }
    
    int returnSize;
    int* result = solution(s, queries, queryCount, &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(Q × N³)

Q queries, each checking O(N²) substrings with O(N) character comparison

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for counting

✓ Linear Space

18.5K Views

Medium Frequency

~25 min Avg. Time

892 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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler